主要内容
- Collection集合
- 迭代器
- 增强for
- 泛型
学习目标
- 能够说出集合与数组的区别
- 说出Collection集合的常用功能
- 能够使用迭代器对集合进行取元素
- 能够说出集合的使用细节
- 能够使用集合存储自定义类型
- 能够使用foreach循环遍历集合
- 能够使用泛型定义集合对象
- 能够理解泛型上下限
- 能够阐述泛型通配符的作用
1、Collection单列集合:存数据时一个个的存
1.1 概述
-
集合:集合是java中提供的一种容器,可以用来存储多个数据。
-
集合和数组既然都是容器,它们有啥区别呢?
-
数组长度固定,集合长度可变
-
数组可存储基本数据类型、对象,是同一类型的元素即可,集合存储的都是对象,而且对象的类型可以不一致
一般开发中,当对象多的时候,推荐使用集合进行存储
-
1.2 集合的框架
- 集合按照其存储结构可以分为两大类,分别是单列集合
java.util.Collection
和双列集合java.util.Map
- Collection:单列集合类的根接口,用于存储一系列符合某种**规则(抽象方法)**的元素
- 两个重要的子接口 ,分别是
java.util.List
和java.util.Set
List
的特点是元素有序、元素可重复、有索引List
接口的主要实现类有java.util.ArrayList
和java.util.LinkedList
Set
的特点是元素无序、不可重复、无索引Set
接口的主要实现类有java.util.HashSet
和java.util.TreeSet
- 两个重要的子接口 ,分别是
- JDK中提供了丰富的集合类库,整个集合类的继承体系:
其中,橙色框里填写的都是接口类型,而蓝色框里填写的都是具体的实现类,集合本身是一个工具,它存放在java.util包中
在Collection
接口定义着单列集合框架中最最共性的内容
1.3 Collection 接口常用功能(增删改查等)
Collection是所有单列集合的父接口,因此在Collection中定义了操作所有单列集合(List和Set)通用的一些方法,如下:
public boolean add(E e)
: 把给定的对象添加到当前集合中 。//增public boolean remove(E e)
: 把给定的对象在当前集合中删除。//删一个public void clear()
: 清空集合中所有的元素。//删除所有public Object[] toArray()
: 把集合中的元素,存储到数组中。//改,变成数组,转换成数组public boolean contains(E e)
: 判断当前集合中是否包含给定的对象。//查,是否包含元素,针对的是一个public boolean isEmpty()
: 判断当前集合是否为空。//查,是否没有元素,针对的是所有情况public int size()
: 返回集合中元素的个数。//查,元素的个数,针对的也是所有情况
案例演示:
Collection<String> al = new ArrayList<>();//多态写法
al.add("abc");
al.add("def");
al.add("hij");
Collections.addAll(al,"k","lmn","opq","rst");
System.out.println("原集合:"+al);
al.remove("abc");
System.out.println("remove后的集合"+al);
Object[] toArray = al.toArray();//.var
System.out.println("toArray为数组:"+Arrays.toString(toArray));
al.clear();
System.out.println("clear后:"+al);
System.out.println(al.contains("abc"));
System.out.println(al.isEmpty());
System.out.println(al.size());
运行结果:
原集合:[abc, def, hij, k, lmn, opq, rst]
remove后的集合[def, hij, k, lmn, opq, rst]
toArray为数组:[def, hij, k, lmn, opq, rst]
clear后:[]
false
true
0
tips: 有关Collection中的方法可不止上面这些,这些只是常用的方法,其他方法可以自行查看API学习。
2、Iterator迭代器:遍历集合
2.1 Iterator接口
在程序开发中,经常需要遍历集合中的所有元素。
针对这种需求,JDK专门提供了一个接口
java.util.Iterator
。
Iterator
接口也是Java集合中的一员,但它与Collection
、Map
接口有所不同,Collection
接口与Map
接口主要用于存储元素,而Iterator
主要用于迭代访问(即遍历)Collection
中的元素,因此Iterator
对象也被称为迭代器。
- 迭代:即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素,如果有,就把这个元素取出来,继续再判断,如果还有就再取出来,直到把集合中的所有元素全部取出。这种取出方式,专业术语称为迭代
public Iterator iterator()
: 获取集合对应的迭代器,用来遍历集合中的元素
-
Iterator接口的常用方法如下:
public boolean hasNext()
:如果仍有元素可以迭代,则返回 truepublic E next()
:返回迭代的下一个元素(迭代器原理内置了一个指针,一开始在集合的外面,每调用一次next方法,指针向下移动一次,得到对应的元素)
-
能够使用迭代器对集合进行取元素:
ArrayList<String> al = new ArrayList<>();//多态
al.add("abc");
al.add("def");
al.add("hij");
//迭代器迭代功能
Iterator<String> iterator = al.iterator();
while(iterator.hasNext()){//判断是否有元素可以迭代,true/false
String next = iterator.next();//返回输出此次迭代元素,后指针后移
System.out.println(next);
}
运行结果:
abc
def
hij
tips::在进行集合元素取出时,如果集合中已经没有元素了,还继续使用迭代器的next方法,将会发生java.util.NoSuchElementException没有这样的元素的异常,即不正常的情况,也就是出现问题
2.2 迭代器的实现原理
Iterator遍历集合的整个过程:
当遍历集合时,首先通过调用t集合的iterator()方法获得迭代器对象,
然后使用hashNext()方法判断集合中是否存在下一个元素,
如果存在,则调用next()方法将元素取出,
在调用Iterator的next方法之前,迭代器的索引位于第一个元素之前,不指向任何元素,
当第一次调用迭代器的next方法后,迭代器的索引会向后移动一位,指向第一个元素并将该元素返回,
当再次调用next方法时,迭代器的索引会指向第二个元素并将该元素返回,
依此类推,直到hasNext方法返回false,表示到达了集合的末尾,终止对元素的遍历。
2.3 增强for
增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环,专门用来遍历数组和集合的
它的内部原理对于集合来说其实是个Iterator迭代器,所以在遍历的过程中,不要对集合中的元素进行增删操作
格式:
for(元素的数据类型 变量 : Collection集合or数组){
//写操作代码
}
它用于遍历Collection单列集合和数组。通常只进行遍历元素,不要在遍历的过程中对集合元素进行增删操作。
练习1:遍历数组(增强for循环遍历数组:底层是个普通for循环,不是迭代器,集合底层才是!!!)
CopyOnWriteArrayList<String> strings = new CopyOnWriteArrayList<String>();
strings.add("abc");
strings.add("def");
strings.add("hij");
for(String e : strings){
if(e.equals("def")){
strings.remove(e);
strings.add("666");
}
}
System.out.println(strings);
运行结果:
[abc, hij, 666]
练习2:遍历单列集合,即(能够使用foreach循环遍历集合)
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("def");
coll.add("hij");
//能够使用foreach循环遍历集合
for(String s :coll){//idea快捷键集合对象名coll.for
System.out.println(s);
}
//增强for循环遍历数组底层是个普通for循环不是迭代器,集合底层才是!!!
//反编译之后底层的上面代码对应的底层代码如下:
for (Iterator iterator = coll.iterator(); iterator.hasNext();System.out.println(s)){
s = (String)iterator.next();//满足条件走这里,然后走控制条件的输出语句打印!!!
}
tips: 新for循环必须有被遍历的目标。目标只能是Collection单列集合或者是数组。新式for仅仅作为遍历操作出现,
**不要在里面进行增删操作!!!**否则有时候会出现问题并发修改异常,所有应该避免这样做!!!
练习3:出现问题并发修改异常:把ArrayList换成CopyOnWriterArrayList
CopyOnWriteArrayList<String> coll = new CopyOnWriteArrayList<String>();
coll.add("abc");
coll.add("def");
coll.add("hij");
//tips: 新for循环必须有被遍历的目标。目标只能是Collection单列集合或者是数组。
//新式for仅仅作为遍历操作出现,不要在里面进行增删操作!!!否则有时候会出现问题,所有应该避免这样做!!!
//扩展
for (String e : coll) {//e代表集合里面的 每一个 元素,遍历,集合对象.for
if (e.equals("def")){
coll.remove(e);//出现ConcurrentModificationException,并发修改异常,问题
}
}
System.out.println(coll);//[abc, hij]
3、泛型
3.1 泛型概述(能够说出集合的使用细节,即加不加泛型的区别)
学习集合时,我们知道集合中是可以存放任意对象的,如果不加泛型,只要把对象存储到集合后,那么这时他们都会被提升成Object类型。
当我们在取出每一个对象,并且进行相应的操作(如取出字符串得到它的长度),这时必须采用类型转换。
而加了泛型,元素的数据类型就规范了,限定了,比如ArrayList只能存储字符串类型
观察下面代码:
Collection coll = new ArrayList();
coll.add("abc");
coll.add("itcast");
coll.add(5);//由于集合没有做任何限定,任何类型都可存放
Iterator it = coll.iterator();
while(it.hasNext()){
//需要打印每个字符串的长度,就要把迭代出来的对象转成String类型,才能调用length方法
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,转移到了编译时期变成了编译失败
- 避免了类型强转的麻烦
如下代码:
Collection<String> list = new ArrayList<String>();
list.add("abc");
list.add("itcast");
// list.add(5); //当集合明确类型后,存放类型不一致就会编译报错
// 集合已经明确具体存放的元素类型,那么在使用迭代器的时候,迭代器也同样会知道具体遍历的元素类型
Iterator<String> it = list.iterator();//要注意指定迭代器里面迭代元素的数据类型,<String>
while(it.hasNext()){
String str = it.next();
//当使用Iterator<String> 控制元素类型后,就不需要强转了。获取到的元素直接就是String类型
System.out.println(str.length());
}
运行结果:
3
6
tips:泛型也是数据类型的一部分,我们将类名与泛型合并一起看做数据类型。比如ArrayList
3.3 泛型的定义与使用(集合中会大量使用泛型)
- **泛型:**用来灵活地将数据类型应用到不同的类、方法、接口当中,将数据类型作为参数进行传递
3.3.1 定义和使用含有泛型的类
定义:
修饰符 class 类名<代表泛型的变量,E,未知类型> { }
//E未知类型写在类里面,当创建这个类的对象的时候指定具体的类型,比如String,理解E=String;
例如,API中的ArrayList集合:定义一个泛型,写一个泛型↓
class ArrayList<E>{ //<E>定义一个泛型,写一个泛型,未知的类型(通用类型),使用泛型就是给E变量进行赋值(创建类的而对象的时候指定)
public boolean add(E e){ } //E=String
public E get(int index){ }
....
}
使用泛型: 即什么时候确定泛型
在创建对象的时候确定泛型
例如,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) { }
...
}
举例自定义泛型类
public class MyGenericClass<MVP> {//MVP未知类型,赋值具体类型
//没有MVP类型,在这里代表 未知的一种数据类型 未来赋值传递什么就是什么类型
private MVP mvp;
public void setMVP(MVP mvp) {
this.mvp = mvp;
}
public MVP getMVP() {
return mvp;
}
}
使用:
public class GenericClassDemo {
public static void main(String[] args) {
// 创建一个泛型为String的类
MyGenericClass<String> my = new MyGenericClass<String>();
// 调用setMVP
my.setMVP("大胡子登登");
// 调用getMVP
String mvp = my.getMVP();
System.out.println(mvp);
//创建一个泛型为Integer的类
MyGenericClass<Integer> my2 = new MyGenericClass<Integer>();
my2.setMVP(123);
Integer mvp2 = my2.getMVP();
}
}
3.3.2 含有泛型的方法
定义格式:
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }//巧记,中间插入尖括号<>
例如,
public class MyGenericMethod {
public <MVP> void show(MVP mvp) {
System.out.println(mvp.getClass());
}
public <MVP> MVP show2(MVP mvp) {
return mvp;
}
//扩展,静态怎么写
public static <MVP> void show3(MVP mvp) {//MVP未知类型泛型<变量>,mvp="lshuhao";String
System.out.println(mvp);
}
//非静态的泛型方法可以用类的方法,也可以方法自己的泛型,如果泛型名字一样,就近原则(方法-没有-类)
//public <Weizhi> void show(Weizhi mvp) {
// System.out.println("mvp是多少谁:"+mvp);
//}
//静态的泛型方法只可以方法自己的泛型,因为静态随着类的加载而加还没有创建对象,没有给类的泛型赋值
//public static <MVP> void show(MVP mvp) {//Integer mvp = 11;//...
// System.out.println("mvp是多少谁:"+mvp);
//}
//静态的泛型方法只可以方法自己的泛型,因为静态随着类的加载而加还没有创建对象,没有给类的泛型赋值↓
//public static void show(Weizhi mvp) {//报错
// System.out.println("mvp是多少谁:"+mvp);
//}
}
使用格式:调用方法时,确定泛型的具体类型
public class GenericMethodDemo {
public static void main(String[] args) {
// 创建对象
MyGenericMethod mm = new MyGenericMethod();
// 演示看方法提示
mm.show("aaa");
mm.show(123);
mm.show(12.45);
}
}
3.3.3 含有泛型的接口
定义格式:
修饰符 interface接口名<代表泛型的变量> { }
例如,
public interface MyGenericInterface<E>{//E=String;
public abstract void add(E e);
public abstract E getE();
}
使用格式:
1、定义类时确定泛型的类型
例如
public class MyImp1 implements MyGenericInterface<String> {
@Override
public void add(String e) {
// 省略...
}
@Override
public String getE() {
return null;
}
}
此时,泛型E的值就是String类型。
2、始终不确定泛型的类型,直到创建对象时,才确定泛型的类型
例如
public class MyImp2<E> implements MyGenericInterface<E> {
@Override
public void add(E e) {
// 省略...
}
@Override
public E getE() {
return null;
}
}
确定泛型:
/*
* 使用
*/
public class GenericInterface {
public static void main(String[] args) {
MyImp2<String> my = new MyImp2<String>();
my.add("aa");
}
}
3.4 泛型通配符
当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>表示
但是注意:一旦使用泛型的通配符?后,只能使用Object类中的共性方法,集合中元素自身方法无法使用!!!
通配符基本使用,即(能够阐述泛型通配符的作用)
泛型的通配符<?>:不知道使用什么类型来接收泛型的时候,此时可以使用?来表示未知通配符。
此时只能接收数据,不能往集合中存储数据。(因为?不确定具体是什么类型,啥类型都可以,所以不知道存什么数据)
举个例子理解使用即可:
public static void main(String[] args) {
Collection<Integer> list1 = new ArrayList<Integer>();
getElement(list1);
Collection<String> list2 = new ArrayList<String>();
getElement(list2);
}
public static void getElement(Collection<?> coll){}//coll= new ArrayList<Integer>();
//?代表可以接收任意类型<?>接收任意的泛型
注意事项:泛型不存在继承关系 ,如Collection list = new ArrayList();这种是错误的。
Collection<Object> list = new ArrayList<String>();//报错,具体类型要求泛型前后是一致的,没有继承关系 Collection<?> list2 = new ArrayList<Object>();//没问题,这就是?通配符可以接收任意的泛型的好处 Collection<?> list3 = new ArrayList<?>();//报错,?未知类型,没有具体的,啥都可以,创建对象要求是具体类型 //爹的泛型由儿子指定的!!!
通配符高级使用----受限泛型,即(能够理解泛型上下限),如下所示:
<? extends 类>表示这个类以及这个类的子类,叫泛型上限,
<? super类>表示这个类以及这个类的父类,叫泛型下限,用来限制泛型的范围,而不像用<?号,啥都可以接收
之前设置泛型的时候,实际上是可以任意设置的,只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。
泛型的上限:
- 格式:
类型名称 <? extends 类 > 对象名称
- 意义:
只能接收该类型及其子类
泛型的下限:
- 格式:
类型名称 <? super 类 > 对象名称
- 意义:
只能接收该类型及其父类型
比如:现已知Object类,String 类,Number类,Integer类,其中Number是Integer的父类,因为整数也是数字
public static void main(String[] args) {
Collection<Integer> list1 = new ArrayList<Integer>();//儿子,是Number的儿子
Collection<String> list2 = new ArrayList<String>();//兄弟
Collection<Number> list3 = new ArrayList<Number>();//兄弟
Collection<Object> list4 = new ArrayList<Object>();//爹
getElement(list1);
getElement(list2);//报错
getElement(list3);
getElement(list4);//报错
getElement2(list1);//报错
getElement2(list2);//报错
getElement2(list3);
getElement2(list4);
}
// 泛型的上限:此时的泛型?,必须是Number类型或者Number类型的子类
记忆下面两个,能够理解泛型上下限
//? extends Number,代表的是Number类及其子类,上限
//? super Number,代表的是Number类及其父类,下限
public static void getElement(Collection<? extends Number> coll){}
// 泛型的下限:此时的泛型?,必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}