Collection集合
集合概述
集合:集合是java中提供的一种容器,可以用来存储多个数据。
集合和数组的区别
- 数组的长度是固定的。集合的长度是可变的。
- 数组中存储的是同一类型的元素,可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候,使用集合进行存储。
学习集合的目标
- 会使用集合存储数据
- 会遍历集合,把数据取出来
- 掌握每种集合的特性
集合框架的学习方式
- 学习顶层:学习顶层接口/抽象类中共性的方法,所有子类都可以使用
- 使用底层:顶层不是接口就是抽象类,需要使用底层的子类创建对象使用
集合框架
JAVASE提供了满足各种需求的API,在使用这些API前,先了解其继承与接口操作架构,才能了解何时采用哪个类,以及类之间如何彼此合作,从而达到灵活应用。集合按照其存储结构可以分为两大类,分别是单列集合 java.util.Collection 和双列集合 java.util.Map。
JDK中提供了丰富的集合类库,为了便于初学者进行系统地学习,接下来通过一张图来描述整个集合类的继承体系。
其中,橙色框里填写的都是接口类型,而蓝色框里填写的都是具体的实现类。
总结:
Collection:是所有单列集合的父接口,因此在Collection中定义了单列集合(List和Set)通用的一些方法,这些方法可用于操作所有的单列集合。它有两个重要的子接口,分别是:java.util.List 和 java.util.Set 。
java.util.List
特点:
- 有序的集合(存储和取出的顺序相同)
- 允许存储重复的元素
- 有索引,可以使用普通的for循环遍历
java.util.Set
特点:
- 不允许存储重复元素
- 没有索引(不能使用普通的for循环的遍历)
Collection 常用功能
Collection是所有单列集合的父接口,因此在Collection中定义了单列集合(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<Integer> collection = new ArrayList<>(); //打印对象名称,不是内存地址就是重写了toString方法 System.out.println(collection);//[] /* public boolean add(E e): 把给定的对象添加到当前集合中 。 返回值是一个boolean值,一般都返回true,所以可以不用接收 */ System.out.println(collection.add(1));//true //添加几个测试元素,按着添加顺序依次存储在ArrayList集合中 for (int i = 0; i < 5; i++) { collection.add(i); } System.out.println(collection);//[1, 0, 1, 2, 3, 4] /* public boolean remove(E e): 把给定的对象在当前集合中删除。 返回值是一个boolean值,集合中存在元素,删除元素,返回true 集合中不存在元素,删除失败,返回false */ //如果给定的元素在ArrayList中有多个,则删除第一个 System.out.println(collection.remove(1));//true System.out.println(collection.remove(5));//false System.out.println(collection);//[0, 1, 2, 3, 4] /* public boolean contains(E e): 判断当前集合中是否包含给定的对象。 包含返回true 不包含返回false */ System.out.println(collection.contains(0));//true System.out.println(collection.contains(5));//false //public boolean isEmpty(): 判断当前集合是否为空。 集合为空返回true,集合不为空返回false System.out.println(collection.isEmpty());//false //public int size(): 返回集合中元素的个数。 System.out.println(collection.size());//5 //public Object[] toArray(): 把集合中的元素,存储到数组中。 Object[] objects = collection.toArray(); //遍历数组 for (int i = 0; i < objects.length; i++) { System.out.print(objects[i] + " ");//0 1 2 3 4 } //public void clear() :清空集合中所有的元素。但是不删除集合,集合还存在 collection.clear(); System.out.println(collection);//[] System.out.println(collection.isEmpty());//true } }
Iterator迭代器
Iterator接口
在程序开发中,经常需要遍历集合中的所有元素。针对这种需求,JDK专门提供了一个接口java.util.Iterator 。 Iterator 接口也是Java集合中的一员,但它与 Collection 、 Map 接口有所不同,Collection 接口与 Map 接口主要用于存储元素,而 Iterator 主要用于迭代访问(即遍历) Collection 中的元素,因此 Iterator 对象也被称为迭代器。想要遍历Collection集合,那么就要获取该集合迭代器完成迭代操作, Collection接口中有一个方法,叫iterator(),这个方法返回的就是迭代器的实现类对象。
- public Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。
下面介绍一下迭代的概念
- 迭代:即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素,如果有,就把这个元素取出来,继续在判断,如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
Iterator接口的常用方法如下:
- public E next() :返回迭代的下一个元素。
- public boolean hasNext() :如果仍有元素可以迭代,则返回 true。
迭代器的使用步骤(重点):
- 使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)
- 使用Iterator接口中的方法hasNext判断还有没有下一个元素
- 使用Iterator接口中的方法next取出集合中的下一个元素
注意:
- 在进行集合元素取出时,如果集合中已经没有元素了,还继续使用迭代器的next方法,将会发生java.util.NoSuchElementException没有集合元素的错误。
举例演示
package demo01; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class Demo01Iterator { public static void main(String[] args) { //创建一个集合对象 Collection<String> coll = new ArrayList<>(); //往集合中添加元素 coll.add("姚明"); coll.add("科比"); coll.add("麦迪"); coll.add("詹姆斯"); coll.add("艾弗森"); /* 1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态) 注意: Iterator<E>接口也是有泛型的,迭代器的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型 */ //多态 接口 实现类对象 Iterator<String> it = coll.iterator(); //2.使用Iterator接口中的方法hasNext判断还有没有下一个元素 while (it.hasNext()) { //3.使用Iterator接口中的方法next取出集合中的下一个元素 String e = it.next(); System.out.println(e); } /* for循环使用迭代器 for(Iterator<String> it2 = coll.iterator();it2.hasNext();){ String e = it2.next(); System.out.println(e); } */ } }
代码执行后的结果
迭代器的实现原理
我们在之前案例已经完成了Iterator遍历集合的整个过程。当遍历集合时,首先通过调用t集合的iterator()方法获得迭代器对象,然后使用hashNext()方法判断集合中是否存在下一个元素,如果存在,则调用next()方法将元素取出,否则说明已到达了集合末尾,停止遍历元素。Iterator迭代器对象在遍历集合时,内部采用指针的方式来跟踪集合中的元素,为了让初学者能更好地理解迭代器的工作原理,接下来通过一个图例来演示Iterator对象迭代元素的过程:
在调用Iterator的next方法之前,迭代器的索引位于第一个元素之前,不指向任何元素,当第一次调用迭代器的next方法后,迭代器的索引会向后移动一位,指向第一个元素并将该元素返回,当再次调用next方法时,迭代器的索引会指向第二个元素并将该元素返回,依此类推,直到hasNext方法返回false,表示到达了集合的末尾,终止对元素的遍历。
增强for
增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环,专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器,所以在遍历的过程中,不能对集合中的元素进行增删操作。
格式:
举例演示
package demo01; import java.util.ArrayList; import java.util.Collection; /* 增强for循环:底层使用的也是迭代器,使用for循环的格式,简化了迭代器的书写 是JDK1.5之后出现的新特性 Collection<E>extends Iterable<E>:所有的单列集合都可以使用增强for public interface Iterable<T>实现这个接口允许对象成为 "foreach" 语句的目标。 增强for循环:用来遍历集合和数组 格式: for(集合/数组的数据类型 变量名: 集合名/数组名){ System.out.println(变量名); } */ public class Demo02Foreach { public static void main(String[] args) { int[] arr = {3, 5, 6, 87}; //使用增强for遍历数组 for (int a : arr) { //a代表数组中的每个元素 System.out.println(a); } System.out.println("=============================="); Collection<String> coll = new ArrayList<String>(); coll.add("小河神"); coll.add("老河神"); coll.add("神婆"); //使用增强for遍历集合 for (String s : coll) { //接收变量s代表被遍历到的集合元素 System.out.println(s); } } }
代码执行后的结果
泛型
泛型概述
在前面学习集合时,我们都知道集合中是可以存放任意对象的,只要把对象存储集合后,那么这时他们都会被提升成Object类型。当我们在取出每一个对象,并且进行相应的操作,这时必须采用类型转换。大家观察下面代码:
package demo02; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class GenericDemo { public static void main(String[] args) { //由于集合没有做任何限定,任何类型都可以给其中存放 Collection coll = new ArrayList(); coll.add("abc"); coll.add(true); coll.add(5); //获取迭代器对象 Iterator it = coll.iterator(); while (it.hasNext()) { //需要打印每个字符串的长度,就要把迭代出来的对象转成String类型 String str = (String) it.next(); System.out.println(str.length()); } } }
程序在运行时发生了问题java.lang.ClassCastException。 为什么会发生类型转换异常呢? 我们来分析下:由于集合中没有指定泛型,默认的类型为Object类型,导致集合什么类型的元素都可以存储。导致取出时强转引发运行时 ClassCastException。 怎么来解决这个问题呢?Collection虽然可以存储各种对象,但实际上通常Collection最好只存储同一类型对象。例如都是存储字符串对象。因此在JDK5之后,新增了泛型(Generic)语法,让你在设计API时可以指定类或方法支持泛型,这样我们使用API的时候也变得更为简洁,并得到了编译时期的语法检查。
泛型的概念
泛型:可以在类或方法中预支地使用未知的类型。泛型也可以看出是一个变量,用来接收数据类型。泛型是数据类型的一部分,我们将类名与泛型合并一起看做数据类型。
使用泛型的好处
- 将运行时期的ClassCastException,转移到了编译时期变成了编译失败。
- 避免了类型强转的麻烦。
通过我们如下代码体验一下:
package demo02; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class GenericDemo1 { public static void main(String[] args) { Collection<String> list = new ArrayList<String>(); list.add("abc"); list.add("java"); // list.add(5);当集合明确类型后,存放类型不一致就会编译报错 // 集合已经明确具体存放的元素类型,那么在使用迭代器的时候,迭代器也同样会知道具体遍历元素类型 Iterator<String> it = list.iterator(); while (it.hasNext()) { //当使用Iterator<String>遍历元素类型后,就不需要强转了。获取到的元素直接就是String类型 String str = it.next(); //可以使用String的所有方法 System.out.println(str.length()); } } }
当然使用泛型有一点点弊端:泛型是什么类型,只能存储什么类型的数据 ,我们可以忽略不计。
泛型的定义与使用
泛型,用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。
定义和使用含有泛型的类
定义格式:
代码举例
package demo02; /* 定义一个含有泛型的类,模拟ArrayList集合 泛型是一个未知的数据类型,当我们不确定什么什么数据类型的时候,可以使用泛型 泛型可以接收任意的数据类型,可以使用Integer,String,Student... */ //定义含有泛型的类 public class GenericClass<E> { // 我们不知道id是什么类型 所以我们可以使用泛型来代替 private E id; public String name; public E getId() { return id; } public void setId(E id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public void eat(String name) { System.out.println("我的名字是:" + name); } }
定义测试类
package demo02; public class Demo02GenericClass { public static void main(String[] args) { //不写泛型默认为Object类型,类中使用泛型的地方可以接收任意类型的数据 GenericClass gc = new GenericClass(); //创建GenericClass对象,泛型使用Integer类型 GenericClass<Integer> gc2 = new GenericClass<>(); // 类中使用泛型的地方只能接收创建对象的时候指定的泛型 gc2.setId(1); //创建GenericClass对象,泛型使用String类型 GenericClass<String> gc3 = new GenericClass<>(); // 类中使用泛型的地方只能接收创建对象的时候指定的泛型 gc3.setId("a"); } }
什么时候确定泛型的类型(使用泛型)
- 在创建对象的时候确定泛型
含有泛型的方法
定义格式:
代码举例
package demo02; /* 定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间 格式: 修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){ 方法体; } 含有泛型的方法,在调用方法的时候确定泛型的数据类型 传递什么类型的参数,泛型就是什么类型 */ public class GenericMethod { //定义一个含有泛型的方法 public <M> void method01(M m){ System.out.println(m); } //定义一个含有泛型的静态方法 public static <S> void method02(S s){ System.out.println(s); } }
定义测试类
package demo02; /* 测试含有泛型的方法 */ public class Demo03GenericMethod { public static void main(String[] args) { //创建GenericMethod对象 GenericMethod gm = new GenericMethod(); /* 调用含有泛型的方法method01 传递什么类型,泛型就是什么类型 */ gm.method01(10); gm.method01("abc"); gm.method01(8.8); gm.method01(true); gm.method02("静态方法,不建议创建对象使用"); //静态方法,通过类名.方法名(参数)可以直接使用 GenericMethod.method02("静态方法"); GenericMethod.method02(1); } }
什么时候确定泛型的类型(使用泛型)
- 调用方法时,确定泛型的类型
含有泛型的接口
定义格式:
代码举例
定义接口GenericInterface
package demo02; //定义含有泛型的接口 public interface GenericInterface<E> { public abstract void method(E i); }
定义实现类GenericInterfaceImpl1
使用泛型方式1:定义类时确定泛型的类型
package demo02; /* 含有泛型的接口,第一种使用方式:定义接口的实现类,实现接口,指定接口的泛型
例如: 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); } }
定义实现类GenericInterfaceImpl2
使用泛型方式2:始终不确定泛型的类型,直到创建对象时,确定泛型的类型
package demo02; /* 含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走 就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型 例如: public class ArrayList<E> implements List<E>{ public boolean add(E e) {} public E get(int index) {} } */ public class GenericInterfaceImpl2<I> implements GenericInterface<I> { @Override public void method(I i) { System.out.println(i); } }
定义测试类
package demo02; /* 测试含有泛型的接口 */ public class Demo04GenericInterface { public static void main(String[] args) { //创建GenericInterfaceImpl1对象,泛型已经有实现类确定 GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1(); gi1.method("字符串"); //创建GenericInterfaceImpl2对象,指定泛型为Integer GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>(); gi2.method(10); //创建GenericInterfaceImpl2对象,指定泛型为Double GenericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>(); gi3.method(8.8); } }
泛型通配符
当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>表示。但是一旦使用泛型的通配符后,只能使用Object类中的共性方法,集合中元素自身方法无法使用。
通配符基本使用
- 泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。此时只能接受数据,不能往该集合中存储数据。
举个例子:
import java.util.ArrayList; import java.util.Iterator; /* 泛型的通配符: ?:代表任意的数据类型 使用方式: 不能创建对象使用 只能作为方法的参数使用 */ public class Demo05Generic { public static void main(String[] args) { ArrayList<Integer> list01 = new ArrayList<>(); list01.add(1); list01.add(2); ArrayList<String> list02 = new ArrayList<>(); list02.add("a"); list02.add("b"); printArray(list01); printArray(list02); //ArrayList<?> list03 = new ArrayList<?>(); } /* 定义一个方法,能遍历所有类型的ArrayList集合 这时候我们不知道ArrayList集合使用什么数据类型,可以泛型的通配符?来接收数据类型 注意: 泛型没有继承概念的 */ public static void printArray(ArrayList<?> list){ //使用迭代器遍历集合 Iterator<?> it = list.iterator(); while(it.hasNext()){ //it.next()方法,取出的元素是Object,可以接收任意的数据类型 Object o = it.next(); System.out.println(o); } } }
通配符高级使用----受限泛型
之前设置泛型的时候,实际上是可以任意设置的,只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。
泛型的上限:
- 格式: 类型名称 <? extends 类 > 对象名称
- 意义: 只能接收该类型及其子类
泛型的下限:
- 格式: 类型名称 <? super 类 > 对象名称
- 意义: 只能接收该类型及其父类型
例如:
// 泛型的上限:此时的泛型?,必须是Number类型或者Number类型的子类 public static void getElement1(Collection<? extends Number> coll){} // 泛型的下限:此时的泛型?,必须是Number类型或者Number类型的父类 public static void getElement2(Collection<? super Number> coll){}
集合综合案例
案例介绍
按照斗地主的规则,完成洗牌发牌的动作。 具体规则:使用54张牌打乱顺序,三个玩家参与游戏,三人交替摸牌,每人17张牌,最后三张留作底牌。
案例分析
准备牌:
- 牌可以设计为一个ArrayList,每个字符串为一张牌。 每张牌由花色数字两部分组成,我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。 牌由Collections类的shufflfflffle方法进行随机排序。
发牌:
- 将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌,剩余牌通过对3取模依次发牌。
看牌
- 直接打印每个集合。
案例实现
package demo02; import java.util.ArrayList; import java.util.Collections; /* 斗地主综合案例: 1.准备牌 2.洗牌 3.发牌 4.看牌 */ public class DouDiZhu { public static void main(String[] args) { //1.准备牌 //定义一个存储54张牌的ArrayList集合,泛型使用String ArrayList<String> poker = new ArrayList<>(); //定义两个数组,一个数组存储牌的花色,一个数组存储牌的序号 String[] colors = {"♠","♥","♣","♦"}; String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"}; //先把大王和小王存储到poker集合中 poker.add("大王"); poker.add("小王"); //循环嵌套遍历两个数组,组装52张牌 for(String number : numbers){ for (String color : colors) { //把组装好的牌存储到poker集合中 poker.add(color+number); } } /* 2.洗牌 使用集合的工具类Collections中的方法 static void shuffle(List<?> list) 使用默认随机源对指定列表进行置换。 */ Collections.shuffle(poker); //System.out.println(poker); /* 3.发牌 */ //定义4个集合,存储玩家的牌和底牌 ArrayList<String> player01 = new ArrayList<>(); ArrayList<String> player02 = new ArrayList<>(); ArrayList<String> player03 = new ArrayList<>(); ArrayList<String> diPai = new ArrayList<>(); /* 遍历poker集合,获取每一张牌 使用poker集合的索引%3给3个玩家轮流发牌 剩余3张牌给底牌 注意: 先判断底牌(i>=51),否则牌就发没了 */ for (int i = 0; i < poker.size() ; i++) { //获取每一张牌 String p = poker.get(i); //轮流发牌 if(i>=51){ //给底牌发牌 diPai.add(p); }else if(i%3==0){ //给玩家1发牌 player01.add(p); }else if(i%3==1){ //给玩家2发牌 player02.add(p); }else if(i%3==2){ //给玩家3发牌 player03.add(p); } } //4.看牌 System.out.println("刘德华:"+player01); System.out.println("周润发:"+player02); System.out.println("周星驰:"+player03); System.out.println("底牌:"+diPai); } }
代码执行后的结果