主要内容
- Collection集合
- 迭代器
- 增强for
- 泛型
第一章 Collection集合
1.1 集合概述
- 在前面基础班我们已经学习过并使用过集合ArrayList ,那么集合到底是什么呢?
集合:集合是java中提供的一种容器,可以用来存储多个数据。
- 集合和数组既然都是容器,它们有啥区别呢?
数组的长度是固定的。集合的长度是可变的。
**数组中存储的是同一类型的元素,可以存储基本数据类型值。集合存储的都是对象。**而且对象的类型可以不
一致。在开发中一般当对象多的时候,使用集合进行存储。
1.2 集合框架
JAVASE提供了满足各种需求的API,在使用这些API前,先了解其继承与接口操作架构,才能了解何时采用哪个类,以及类之间如何彼此合作,从而达到灵活应用。
集合按照其存储结构可以分为以下两大类:
- 单列集合java.util.Collection
- 双列集合java.util.Map
今天我们主要学习Collection 集合,先来看下Collection 集合的继承体系
Collection :单列集合类的根接口,用于存储一系列符合某种规则的元素,它有两个重要的子接口,分别是java.util.List 和java.util.Set 。其中, List 的特点是元素有序、元素可重复。Set 的特点是元素无序,而且不可重复。List 接口的主要实现类有java.util.ArrayList 和java.util.LinkedList , Set 接口的主要实现类有java.util.HashSet 和java.util.LinkedHashSet 。
集合本身是一个工具,它存放在java.util包中。在Collection 接口定义着单列集合框架中最最共性的内容。
1.3 Collection 常用方法
Collection是所有单列集合的父接口,因此在Collection中定义了单列集合(List和Set)通用的一些方法,这些方法可
用于操作所有的单列集合。方法如下:
public boolean add(E e) : 把给定的对象添加到当前集合中 。
public void clear() :清空集合中所有的元素。
boolean remove(E e) : 把给定的对象在当前集合中删除。
boolean contains(E e) : 判断当前集合中是否包含给定的对象。
public boolean isEmpty() : 判断当前集合是否为空。
public int size() : 返回集合中元素的个数。
public Object[] toArray() : 把集合中的元素,存储到数组中。
方法演示:
import java.util.ArrayList;
import java.util.Collection;
public class Demo1Collection {
public static void main(String[] args) {
// 创建集合对象
// 使用多态形式
Collection<String> coll = new ArrayList<String>();
// 使用方法
// 添加功能 boolean add(String s)
coll.add("小李广");
coll.add("扫地僧");
coll.add("石破天");
System.out.println(coll);
// boolean contains(E e) 判断o是否在集合中存在
System.out.println("判断 扫地僧 是否在集合中"+coll.contains("扫地僧"));
//boolean remove(E e) 删除在集合中的o元素
System.out.println("删除石破天:"+coll.remove("石破天"));
System.out.println("操作之后集合中元素:"+coll);
// size() 集合中有几个元素
System.out.println("集合中有"+coll.size()+"个元素");
// Object[] toArray()转换成一个Object数组
Object[] objects = coll.toArray();
// 遍历数组
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}
// void clear() 清空集合
coll.clear();
System.out.println("集合中内容为:"+coll);
// boolean isEmpty() 判断是否为空
System.out.println(coll.isEmpty());
}
}
tips: 有关Collection中的方法可不止上面这些,其他方法可以自行查看API学习。
第二章 Iterator迭代器
2.1 Iterator接口概述
在程序开发中,经常需要遍历集合中的所有元素。针对这种需求,JDK专门提供了一个接口
java.util.Iterator
。Iterator
接口也是Java集合中的一员,但它与Collection
、Map
接口有所不同,
Collectio
n 接口与Map
接口主要用于存储元素,而Iterator
主要用于迭代访问(即遍历) Collection
中的元素,因此Iterator
对象也被称为迭代器。
想要遍历Collection集合,那么就要获取该集合迭代器完成迭代操作,下面介绍一下获取迭代器的方法:
public Iterator iterator() : 获取集合对应的迭代器,用来遍历集合中的元素的。
下面介绍一下迭代的概念:
迭代:即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素,如果有,就把这个
**元素取出来,继续在判断,如果还有就再取出出来。一直把集合中的所有元素全部取出。**这种取出方式专业
术语称为迭代。
2.2 Iterator常用方法
public E next() :返回迭代的下一个元素。
public boolean hasNext() :如果仍有元素可以迭代,则返回 true。
2.3 Iterator示例代码
接下来我们通过案例学习如何使用Iterator迭代集合中元素:
public class IteratorDemo {
public static void main(String[] args) {
// 使用多态方式 创建对象
Collection<String> coll = new ArrayList<String>();
// 添加元素到集合
coll.add("串串星人");
coll.add("吐槽星人");
coll.add("汪星人");
//遍历
//使用迭代器 遍历 每个集合对象都有自己的迭代器
Iterator<String> it = coll.iterator();
// 泛型指的是 迭代出 元素的数据类型
while(it.hasNext()){ //判断是否有迭代元素
String s = it.next();//获取迭代出的元素
System.out.println(s);
}
}
}
tips::在进行集合元素取出时,如果集合中已经没有元素了,还继续使用迭代器的next方法,将会发生
java.util.NoSuchElementException没有集合元素的错误。
2.4 迭代器的实现原理
我们在之前案例已经完成了Iterator遍历集合的整个过程。当遍历集合时,首先通过调用t集合的iterator()方法获得
迭代器对象,然后使用hashNext()方法判断集合中是否存在下一个元素,如果存在,则调用next()方法将元素取
出,否则说明已到达了集合末尾,停止遍历元素。
Iterator迭代器对象在遍历集合时,内部采用指针的方式来跟踪集合中的元素,为了让初学者能更好地理解迭代器
的工作原理,接下来通过一个图例来演示Iterator对象迭代元素的过程:
在调用Iterator的next方法之前,迭代器的索引位于第一个元素之前,不指向任何元素,当第一次调用迭代器的
next方法后,迭代器的索引会向后移动一位,指向第一个元素并将该元素返回,当再次调用next方法时,迭代器的索引会指向第二个元素并将该元素返回,依此类推,直到hasNext方法返回false,表示到达了集合的末尾,终止对元素的遍历。
第三章 增强for
3.1 增强for概述
增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环。
专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器,所以在遍历的过程中,不能对集合中的元素
进行增删操作。
3.2 增强for格式
for(元素的数据类型 变量 : Collection集合or数组){
//写操作代码
}
它用于遍历Collection和数组。通常只进行遍历元素,不要在遍历的过程中对集合元素进行增删操作。
3.3 增强for演示示例
练习1:遍历数组
public class NBForDemo1 {
public static void main(String[] args) {
int[] arr = {3,5,6,87};
//使用增强for遍历数组
for(int a : arr){//a代表数组中的每个元素
System.out.println(a);
}
}
}
练习2:遍历集合
public class NBFor {
public static void main(String[] args) {
Collection<String> coll = new ArrayList<String>();
coll.add("小河神");
coll.add("老河神");
coll.add("神婆");
//使用增强for遍历
for(String s :coll){//接收变量s代表 代表被遍历到的集合元素
System.out.println(s);
}
}
}
tips: 新for循环必须有被遍历的目标。目标只能是Collection或者是数组。新式for仅仅作为遍历操作出现。
第四章 泛型
3.1 回顾泛型在集合中使用
在前面学习集合时,我们都知道集合中是可以存放任意对象的,只要把对象存储集合后,那么这时他们都会被提升
成Object类型。当我们在取出每一个对象,并且进行相应的操作,这时必须采用类型转换。
大家观察下面代码:
public class GenericDemo {
public static void main(String[] args) {
ArrayList coll = new ArrayList();
coll.add("abc");
coll.add("itcast");
coll.add(5);//由于集合没有做任何限定,任何类型都可以给其中存放
Iterator it = coll.iterator();
while(it.hasNext()){
//需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
String str = (String) it.next();
System.out.println(str.length());
}
}
}
程序在运行时发生了问题java.lang.ClassCastException。 为什么会发生类型转换异常呢? 我们来分析下:由于
集合中什么类型的元素都可以存储。导致取出时强转引发运行时 ClassCastException。 怎么来解决这个问题呢?
Collection虽然可以存储各种对象,但实际上通常Collection只存储同一类型对象。例如都是存储字符串对象。因此在JDK5之后,新增了泛型(Generic)语法,让你在设计API时可以指定类或方法支持泛型,这样我们使用API的时候也变得更为简洁,并得到了编译时期的语法检查。
泛型:可以在类或方法中预支地使用未知的类型。
tips:一般在创建对象时,将未知的类型确定具体的类型。当没有指定泛型时,默认类型为Object类型。
3.2 使用泛型的好处
上一节只是讲解了泛型的引入,那么泛型带来了哪些好处呢?
- 将运行时期的ClassCastException,转移到了编译时期变成了编译失败。
- 避免了类型强转的麻烦。
使用泛型改写上一节的代码:
public class GenericDemo2 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("abc");
list.add("itcast");
// list.add(5);//当集合明确类型后,存放类型不一致就会编译报错
// 集合已经明确具体存放的元素类型,那么在使用迭代器的时候,迭代器也同样会知道具体遍历元素类型
Iterator<String> it = list.iterator();
while(it.hasNext()){
String str = it.next();
// 当使用Iterator<String>控制元素类型后,就不需要强转了。获取到的元素直接就是String类型
System.out.println(str.length());
}
}
}
tips:泛型是数据类型的一部分,我们将类名与泛型合并一起看做数据类型。
3.3 泛型的定义与使用
我们在集合中会大量使用到泛型,这里来完整地学习泛型知识。
- 泛型是jdk1.5出现的新特性。
- 泛型变量可以理解为是一种数据类型的占位符。
- 泛型变量也可以理解为是一种数据类型的变量。
- 泛型变量的命名规则:只要符合标志符的命名规则即可,一般使用一个大写字母表示
3.3.1 泛型方法
泛型方法引入
定义一个方法接收一个任意类型的参数,返回值类型与实际参数类型一致。
泛型方法概念
在方法声明上使用了泛型变量的方法。
定义格式
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }
示例代码
public class GenericMethodDemo {
public static void main(String[] args) {
// 演示看方法提示
String str = show("aaa");
Integer in = show(123);
Double d = show(12.45);
}
public static <T> T show(T obj){
return obj;
}
}
注意事项
什么时候确定方法泛型变量的具体数据类型?调用方法时,确定泛型的类型,如果没有指定,则默认是
Object
3.3.2 泛型类
泛型类的引入
-
定义一个数组工具类MyArrays
-
提供两个成员方法,方法参数接收一个任意类型的数组
一个方法的功能是将数组的元素反转.
一个方法的功能是将数组的元素拼接成一个字符串返回。如字符串格式:"[1,2,3,4,5]"
泛型类概念
在类定义上使用了泛型变量的类。
定义格式
修饰符 class 类名<代表泛型的变量> { }
例如,API中的ArrayList集合
class ArrayList<E>{
public boolean add(E e){ }
public E get(int index){ }
....
}
示例代码
public class MyArrays<T>{
/**
* 反转数组元素
*/
public void reverse(T[] arr) {
for(int i = 0,j = arr.length ‐ 1;i < j; i++,j‐‐) {
T temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
/**
* 将数组元素拼接成指定的字符串
*/
public String toString(T[] arr) {
StringBuilder sb = new StringBuilder("[");
for (T t : arr) {
sb.append(t).append(",");
}
sb.deleteCharAt(sb.length()‐1);
sb.append("]");
return sb.toString();
}
/**
* 静态方法:泛型方法
*/
public static <T> String toString1(T[] arr) {
StringBuilder sb = new StringBuilder("[");
for (T t : arr) {
sb.append(t).append(",");
}
sb.deleteCharAt(sb.length()‐1);
sb.append("]");
return sb.toString();
}
}
使用泛型类
public class GenericClassDemo {
public static void main(String[] args) {
// 整型数组
Integer[] arr = {1,2,3,4,5};
// 字符串数组
String[] strs = {"a","b","c"};
// 创建MyArrays对象
MyArrays<String> my = new MyArrays<String>();
my.reverse(strs);
System.out.println(my.toString(strs));
// 创建MyArrays对象
MyArrays<Integer> my1 = new MyArrays<>();
my1.reverse(arr);
System.out.println(my1.toString(arr));
System.out.println(MyArrays.toString1(arr));
System.out.println(MyArrays.toString1(strs));
}
}
注意事项
- 什么时候确定泛型变量的具体数据类型? 在创建对象的时候确定泛型变量具体数据类型,如果没有指定,默
认是Object - 静态方法不能使用泛型类上定义的泛型变量,如果静态方法中需要使用泛型变量,则需要将该方法定义为泛
型方法。
例如:
ArrayList<String> list = new ArrayList<String>();
此时,变量E的值就是String类型,那么我们的类型就可以理解为:
class ArrayList<String>{
public boolean add(String e){ }
public String get(int index){ }
...
}
再例如
ArrayList<Integer> list = new ArrayList<Integer>();
此时,变量E的值就是Integer类型,那么我们的类型就可以理解为:
class ArrayList<Integer> {
public boolean add(Integer e) { }
public Integer get(int index) { }
...
}
3.3.3 泛型接口
泛型接口概念
- 在接口定义上使用了泛型变量的接口。
定义格式
修饰符 interface接口名<代表泛型的变量> { }
示例代码
/**
* 数据访问层:直接跟数据库打交道,对数据库进行增删改查操作
*/
public interface Dao<T> {
public void save(T t);
public void update(T t);
public void delete(int id);
public T findById(int id);
}
使用格式
1、实现接口的同时确定泛型变量的具体数据类型
public class StudentDao implements Dao<Student> {
@Override
public void save(Student t) {
}
@Override
public void update(Student t) {
}
@Override
public void delete(int id) {
}
@Override
public Student findById(int id) {
return null;
}
}
public class ProductDao implements Dao<Product> {
@Override
public void save(Product t) {
}
@Override
public void update(Product t) {
}
@Override
public void delete(int id) {
}
@Override
public Product findById(int id) {
return null;
}
}
/*
* 使用:创建对象时不需要确定泛型变量的具体数据类型了
*/
public class GenericInterface {
public static void main(String[] args) {
// 创建StudentDao对象
StudentDao stuDao = new StudentDao();
stuDao.save(new Student());
// 创建ProductDao对象
ProductDao pd = new ProductDao();
pd.save(new Product());
}
}
2、实现接口时不指定泛型变量具体数据类型,将实现类定义为泛型类,在创建实现类对象指定泛型变量的具体数
据类型
public class BaseDao<T> implements Dao<T> {
@Override
public void save(T t) {
}
@Override
public void update(T t) {
}
@Override
public void delete(int id) {
}
@Override
public T findById(int id) {
return null;
}
}
/*
* 使用:创建对象时确定泛型的类型
*/
public class GenericInterface {
public static void main(String[] args) {
// 创建BaseDao对象
BaseDao<Student> stuDao = new BaseDao<>();
stuDao.save(new Student());
// 创建BaseDao对象
BaseDao<Product> pd = new BaseDao<>();
pd.save(new Product());
}
}
3.4 泛型上下限
3.4.1 泛型上下限引入
需求1
‐ 定义一个方法可以接收任意类型的集合对象
‐ 集合对象只能存储Integer或者是Integer的父类数据。
‐ 需求2
‐ 定义一个方法可以接收任意类型的集合对象
‐ 集合对象只能存储Number或者是Number的子类数据。
3.4.2 泛型上下限格式
泛型的上限:
格式: <? extends 类 >
意义: 只能接收该类型及其子类
泛型的下限:
格式: <? super 类 >
意义: 只能接收该类型及其父类型
注意事项
- ? 代表泛型通配符,可以匹配任意的类型。
- 通配符? 不能用在泛型方法、泛型类、泛型接口定义上。
- 通配符? 一般不会单独使用,一般都会配合泛型上下限使用。
3.4.3 示例代码
public class Demo05{
public static void main(String[] args) {
ArrayList<Number> list01 = new ArrayList<>();
ArrayList<Integer> list02 = new ArrayList<>();
ArrayList<Object> list03 = new ArrayList<>();
print01(list01);
print01(list02);
print01(list03);
print02(list01);
print02(list02);
// print02(list03);
}
/**
* 需求2
‐ 定义一个方法可以接收任意类型的集合对象
‐ 集合对象只能存储Number或者是Number的子类数据。
* @param list
*/
public static void print02(ArrayList<? extends Number> list) {
}
/**
* ‐ 定义一个方法可以接收任意类型的集合对象
‐ 集合对象只能存储Integer或者是Integer的父类数据。
* @param list
*/
public static void print01(ArrayList<? super Integer> list) {
}
}