day02【Collection、泛型】
主要内容
- Collection集合
- 迭代器
- 增强for
- 泛型
教学目标
- [ ] 能够说出集合与数组的区别
- [ ] 说出Collection集合的常用功能
- [ ] 能够使用迭代器对集合进行取元素
- [ ] 能够说出集合的使用细节
- [ ] 能够使用集合存储自定义类型
- [ ] 能够使用foreach循环遍历集合
- [ ] 能够使用泛型定义集合对象
- [ ] 能够理解泛型上下限
- [ ] 能够阐述泛型通配符的作用
集合
1.集合框架的学习方式
- 学习顶层:学习顶层的接口/抽象类中共性的方法,所有子类都可以使用。
- 使用底层:底层不是接口就是抽象类,无法直接创建对象使用。需要使用底层的子类创建对象使用
2.学习集合的目标
- 会使用集合储存数据
- 会遍历集合,把数据取出来
- 掌握每种集合的特性
继承:子类共性抽取,形成父类(接口)
第一章 Collection集合
1.1 集合概述
- 集合:集合是Java中提供的一种容器,可以用来存储多个数据。
集合和数组都是容器,区别
- 数组的长度固定。
- 数组存储的是同一类型的元素,可以存储基本数据类型的值。
- 集合的长度是可变的。
- 集合存储的都是对象。而且对象可以不一致。在开发中一般对象多的是后续,使用集合进行存储。
1.2 集合框架
JAVASE提供了满足需求的API,在使用这些API前,先了解其继承与接口操作架构,才能;了解何时采用哪个类,以及类之间如何彼此合作,从而达到灵活运用。
集合按照其存储结构可以分为两大类,分别是单列集合java.util.Collection
和双集合java。util.Map
继承:子类共性抽取,形成父类(接口)
Collection接口
- 定义的是所有单列集合中共性的方法
- 所有的单列集合都可以使用共性的方法
- 没有带索引的方法
Collection接口包括
1.List接口
- 有序的集合(储存和取出元素顺序相同)
- 允许存储重复的元素
- 有索引,可以使用普通的for循环遍历
List接口包括
- Vector集合
- ArrayList集合
- LinkedList集合
2.Set接口
无序的集合:
储存和取出元素的顺序有可能不一致
- 不允许重复元素
- 没有索引(不能使用普通的for循环遍历)
Set接口包括
- TreeSet集合
- HashSet集合
- LinkedHashSet集合(继承自HashSet集合)
1.3 Collection常用功能
Collecntion是所有单列集合的父接口,因此在Collecntion中定义了单列集合(List和Set)通用的一些方法,这些方法可以用于操作所有的单列集合。方法如下:
public boolean add(E e)
:把给定的对象添加到当前集合中。public void clear()
:清空集合中所有的元素。public boolean remove(E e)
:把给定的对象在当前集合中删除。public boolean contains(E e)
: 判断当前集合中是否包含给定的对象。public boolean isEmpty()
:判断当前集合是否为空。public int size()
:返回集合中元素的个数。public object[] toArray()
:把集合中的元素,储存到数组中。
方法演示:
import java.util.ArrayList;
import java.util.Collection;
public class Demo01Collection{
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) 判断是否在集合中存在
System.out.println("判断 雷神是否存在集合中"+coll.contains("雷神"));
// boolean remove(E e) 删除在集合中的元素
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接口
Iterator接口对数组进行遍历
在程序开发中,经常需要遍历集合中的所有元素。针对需求,JDK专门提供了一个接口java.util.Iterator
.Iterator接口也是java结合中的一员。
Collection接口与Map接口主要用于储存元素,而Iterator主要用于迭代访问(即遍历)Collection中的元素,因此Iterator对象也被称为迭代器
java.util.Iterator接口:迭代器(对接口进行遍历)
有两个常用方法
boolean hasNext() 如果仍有元素可以迭代,则返回 true
就是判断集合中还有没有下一个元素,有就返回 true ,没有就返回false
E next() 返回迭代的下一个元素
--> 取出集合中的下一个元素。
Iterator迭代器,是一个接口,无法直接使用,需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊。
Collection接口中有一个方法,叫iterator(),这个方法返回的就是迭代器得到实现类对象
Iterator
使用步骤(重点)
-
使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)。
注意:
Iterator
接口中也是有泛型的,迭代器的泛型和集合的一致。 -
使用Iterator接口中的方法hasNext判断还有没有下一个元素
-
使用Iterator接口中的方法next取出集合中的下一个元素
public class Demo02Iterator {
public static void main(String[] args) {
// 创建一个集合对象
Collection<String> coll = new ArrayList<>();
// 往集合中添加元素
coll.add("姚明");
coll.add("科比");
coll.add("詹姆斯");
coll.add("麦迪");
coll.add("艾弗森");
/*
* 使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)。
注意:
Iterator<E> 接口中也是有泛型的,迭代器的泛型和集合的一致。
* */
// 多态 接口 实现类对象
Iterator<String> it = coll.iterator();
// 或者使用循环
// while循环
while (it.hasNext()) {
String s = it.next();
System.out.println(s);
}
System.out.println("-------------");
// for 循环
for (Iterator<String> it2 = coll.iterator(); it2.hasNext(); ) {
String e = it2.next();
System.out.println(e);
}
/* // 2.使用Iterator接口中的方法hasNext判断还有没有下一个元素
boolean b = it.hasNext();
System.out.println(b);
// 3. 使用Iterator接口中的方法next取出集合中的下一个元素
String s = it.next();
System.out.println(s);
s = it.next();
System.out.println(s);
s = it.next();
System.out.println(s);
s = it.next();
System.out.println(s);
s = it.next();
System.out.println(s);
b = it.hasNext();
System.out.println(b);
*/
}
}
2.2 迭代器的实现原理
我们在之前案例已经完成了Iterator遍历集合的整个过程。当遍历集合时,首先通过调用t集合的iterator()方法获得迭代器对象,然后使用hashNext()方法判断集合中是否存在下一个元素,如果存在,则调用next()方法将元素取出,否则说明已到达了集合末尾,停止遍历元素。
Iterator迭代器对象在遍历集合时,内部采用指针的方式来跟踪集合中的元素,为了让初学者能更好地理解迭代器的工作原理,接下来通过一个图例来演示Iterator对象迭代元素的过程:
在调用Iterator的next方法之前,迭代器的索引位于第一个元素之前,不指向任何元素,当第一次调用迭代器的next方法后,迭代器的索引会向后移动一位,指向第一个元素并将该元素返回,当再次调用next方法时,迭代器的索引会指向第二个元素并将该元素返回,依此类推,直到hasNext方法返回false,表示到达了集合的末尾,终止对元素的遍历。
2.3 增强for
增强for循环:底层使用的是迭代器,使用for循环的格式简化了迭代器的书写
是JDK1.5之后出现的新特性
Collection
public interface Iterable
增强for循环:用来遍历集合和数组
格式
For(集合/数组的数据类型 变量名 :数组名/集合名){
// 操作代码
}
它用于遍历Collection和数组。通常只进行遍历元素,不要在遍历的过程中对集合元素进行增删操作。
练习1:遍历数组
public static void main(String[] args) {
int[] arr = {1,2,3,5,6,9};
// 使用增强for遍历数组
for(int i:arr){
// i 代表数组中的每个元素
System.out.println(i);
}
}
练习2:遍历集合
public static void main(String[] args) {
Collection<String> coll = new ArrayList<String>();
coll.add("神婆");
coll.add("巫女");
coll.add("神算子");
// 使用增强for遍历
for(String str:coll){
// 接收变量str代表被便利的集合元素
System.out.println(str);
}
}
tips: 新for循环必须有被遍历的目标。目标只能是Collection或者是数组。新式for仅仅作为遍历操作出现。
第三章 泛型
在JDK5之后,新增了泛型(Generic)语法,让你在设计API时可以指定类或方法支持泛型,这样我们使用API的时候也变得更为简洁,并得到了编译时期的语法检查。
**泛型:**可以看做是一种未知的数据类型,不知道使用什么数据类型的时候,可以使用泛型
泛型也可以看成是一个变量,用来接收数据类型
E e:Element 元素
T t:Type 类型
3.1 泛型概述
集合可以存放任意对象,只要把对象储存集合后,那么都会被提升为Object类型。
代码如下
/**
创建集合对象,不使用泛型
好处:
集合不使用泛型,默认的类型就是Object类型,可以存储任意类型的数据
弊端:
不安全,会引发异常
*/
public static void main(String[] args){
Collection coll = new ArrayList();
// 集合没有限制 可以存放任意类型
coll.add("abc");
coll.add("itcast");
coll.add(1);
// 使用迭代器 Iterator迭代器,是一个接口,无法直接使用,需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊。
Iterator it = coll.iterator();
while(it.hasNext()){
// 获取元素
Object next = it.next();
System.out.println(next);
// 想要使用string类特有的方法,length获取字符串的长度;不能使用 多态 object obj = "abc"
// 就需要把迭代出来的对象转成String类型
String str = (String) it.next();
System.out.println(it.length());
}
}
程序在运行的时候发生异常
java.lang.ClassCastException。
发生类型转换异常的原因:
由于集合中什么类型的元素都可以存储。导致取出时强转引发运行时 ClassCastException。
Collection集合虽然可以存储各种对象,但实际上只能储存同一类型的对象。
因此在JDK5之后,新增了泛型(Generic)语法,让你在设计API时可以指定类或方法支持泛型,这样我们使用API的时候也变得更为简洁,并得到了编译时期的语法检查。
- 泛型:可以在类或方法中预支地使用未知的类型。
tips:一般在创建对象时,将未知的类型确定具体的类型。当没有指定泛型时,默认类型为Object类型。
3.2 使用泛型的好处
创建集合,使用泛型
好处:
1.避免了类型转换的麻烦,储存的类型固定
2.把运行期异常(代码运行之后会抛出的异常),提升到了编译器(写代码的时候会报错)
弊端:
泛型是什么类型,只能存什么类型
public static void main(String[] args){
Collection<String> list = new ArrayList<>();
list.add("abc");
list.add("iteraton");
// list.add(6); 当集合存储类型确定后,存放的类型不一致就会报错
Iterator<String> it = list.iterator();
while(it.hasNaxt){
String str = it.next();
//当使用Iterator<String>控制元素类型后,就不需要强转了。获取到的元素直接就是String类型
System.out.println(str.length());
}
}
tips:泛型是数据类型的一部分 ,我们将类名与泛型合并一起看做数据类型。
3.3 泛型的定义与使用
泛型,用来灵活的将数据类型应用到不同的类、方法、接口中。将数据类型作为参数进行传递
1.定义和使用含有泛型的类
定义格式:
修饰符 class 类名<代表泛型的变量> { }
例如,API中的ArrayList集合:
class ArrayList<E>{
public boolean add(E e){ }
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类型,在这里代表 未知的一种数据类型 未来传递什么就是什么类型
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();
}
}
2.定义含有泛型的方法
定义含有泛型的方法:泛型定义在方法的修饰符合返回值类型之间
定义格式:
修饰符 <泛型> 返回值类性 方法名(参数列表(使用泛型)){
方法体;
}
含有泛型的方法,在调用的方法的时候确定泛型的数据类型
传递什么类型的参数,泛型就是什么类型
定义泛型类
public class GenericMethod{
public <M> void method1(M m){
System.out.println(m);
}
// 静态方法
public static <S> void method2(S s){
System.out.println(s);
}
}
定义测试类:
public static void main(String[] args){
// 创建GenericMethod对象
GenericMethod gm = new GenericMethod();
/*
调用含有泛型的方法method01
传递什么类型,泛型就是什么类型
*/
gm.method01("acb");
gm.method01(1);
// 静态方法不建议创建对象
// 直接通过类名.方法名调用
Generic.method02("静态方法");
Generic.method02(123);
}
3.含有泛型的接口
定义格式:
修饰符 interface 接口名<代表泛型的变量>{
}
使用格式:
1.始终不确定泛型的类型,直到创建对象时,确定泛型的类型
例如
定义含有泛型的接口
public interface GenericInterface<I>{
public abstract void method(I i):
}
接口的实现类
/**
* 含有泛型的接口,第一种使用方式:定义接口的实现类,实现接口,指定接口的泛型
* public interface Interctor<E>{
* E next();
* }
* Scanner类实现了Iterator接口,并指定接口的泛型为String,所以重写的next方法默认的就是String
* public final class Scanner implements Iterator<String>{
* public String next(){}
* }</>
* */
public class GenericInterfaceImpl1 implements GenericInterface<String> {
@Override
public void method(String s) {
System.out.println(s);
}
}
测试类
public class Demo04GenericInterface {
public static void main(String[] args) {
GenericInterfaceImpl1 impl1 = new GenericInterfaceImpl1();
impl1.method("abc");
impl1.method("字符串");
}
}
2.定义类时确定泛型的类型
定义含有泛型的接口
public interface GenericInterface<I>{
public abstract void method(I i):
}
接口的实现类
public class GenericInterfaceImpl2<I> implements GenericInterface<I>{
@Override
public void method(I i) {
System.out.println(i);
}
}
测试类
public class Demo04GenericInterface {
public static void main(String[] args) {
GenericInterfaceImpl1<String> impl1 = new GenericInterfaceImpl1();
impl1.method("abc");
impl1.method("字符串");
}
3.4 泛型通配符
当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>表示。但是一旦使用泛型的通配符后,只能使用Object类中的共性方法,集合中元素自身方法无法使用。
1.通配符基本使用
泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。
此时只能接受数据,不能往该集合中存储数据。
示例代码:
public static void main(String[] args){
ArrayList<String> list1 = new ArrayList<>();
list1.add("a");
list1.add("b");
// 使用多态写法
Collection<Integer> list2 = new ArrayList<>();
list2.add(1);
list2.add(2);
method(list1);
method(list2);
}
/*
定义一个方法,能遍历所有类型的ArrayList集合
因为不确定ArrayList集合的数据类型,所以使用泛型的通配符?来接收数据类型
注意:
泛型没有继承的概念的
*/
public static void method(Collection<?> list){
// 使用迭代器遍历集合
Iterator<?> it = list.iterator();
while(it.hasNext()){
// it.next()方法,取出的元素是object,可以接受任意的数据类型
Object o = it.next();
System.out.println(o);
}
}
tips:泛型不存在继承关系 Collection