Java语言进阶 day02【Collection、泛型】

主要内容

• Collection集合
• 迭代器
• 增强for
• 泛型

教学目标

能够说出集合与数组的区别

说出 Collection 集合的常用功能

能够使用迭代器对集合进行取元素

能够说出集合的使用细节

能够使用集合存储自定义类型

能够使用 foreach 循环遍历集合

能够使用泛型定义集合对象

能够理解泛型上下限

能够阐述泛型通配符的作用

第一章 Collection 集合

1.1 集合概述

在前面基础班我们已经学习过并使用过集合 ArrayList , 那么集合到底是什么呢 ?

集合 ：集合是 java 中提供的一种容器，可以用来存储多个数据。

集合和数组既然都是容器，它们有啥区别呢？

数组的长度是固定的。集合的长度是可变的。

数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不

一致。在开发中一般当对象多的时候，使用集合进行存储。

1.2 集合框架

JAVASE 提供了满足各种需求的 API ，在使用这些 API 前，先了解其继承与接口操作架构，才能了解何时采用哪个类，

以及类之间如何彼此合作，从而达到灵活应用。

集合按照其存储结构可以分为两大类，分别是单列集合 java.util.Collection 和双列集合 java.util.Map ，今天

我们主要学习 Collection 集合，在 day04 时讲解 Map 集合。 Collection ：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是

java.util.List 和 java.util.Set 。其中， List 的特点是元素有序、元素可重复。 Set 的特点是元素无

序，而且不可重复。 List 接口的主要实现类有 java.util.ArrayList 和 java.util.LinkedList ， Set 接口

的主要实现类有 java.util.HashSet 和 java.util.TreeSet 。

从上面的描述可以看出 JDK 中提供了丰富的集合类库，为了便于初学者进行系统地学习，接下来通过一张图来描述

整个集合类的继承体系。

其中，橙色框里填写的都是接口类型，而蓝色框里填写的都是具体的实现类。这几天将针对图中所列举的集合类进

行逐一地讲解。

集合本身是一个工具，它存放在 java.util 包中。在 Collection 接口定义着单列集合框架中最最共性的内容。

1.3 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() : 把集合中的元素，存储到数组中。

方法演示：

tips: 有关 Collection 中的方法可不止上面这些，其他方法可以自行查看 API 学习。

第二章 Iterator 迭代器

2.1 Iterator 接口

在程序开发中，经常需要遍历集合中的所有元素。针对这种需求， JDK 专门提供了一个接口

java.util.Iterator 。 Iterator 接口也是 Java 集合中的一员，但它与 Collection 、 Map 接口有所不同，

Collection 接口与 Map 接口主要用于存储元素，而 Iterator 主要用于迭代访问(即遍历) Collection 中的元

素，因此 Iterator 对象也被称为迭代器。

想要遍历 Collection 集合，那么就要获取该集合迭代器完成迭代操作，下面介绍一下获取迭代器的方法：

public Iterator iterator() : 获取集合对应的迭代器，用来遍历集合中的元素的。

下面介绍一下迭代的概念：

// 创建集合对象

// 使用多态形式

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 ());

}

} 迭代 ：即 Collection 集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个

元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业

术语称为迭代。

Iterator 接口的常用方法如下：

public E next() : 返回迭代的下一个元素。

public boolean hasNext() : 如果仍有元素可以迭代，则返回 true 。

接下来我们通过案例学习如何使用 Iterator 迭代集合中元素：

tips: ：在进行集合元素取出时，如果集合中已经没有元素了，还继续使用迭代器的 next 方法，将会发生

java.util.NoSuchElementException 没有集合元素的错误。

2.2 迭代器的实现原理

我们在之前案例已经完成了 Iterator 遍历集合的整个过程。当遍历集合时，首先通过调用 t 集合的 iterator() 方法获得

迭代器对象，然后使用 hashNext() 方法判断集合中是否存在下一个元素，如果存在，则调用 next() 方法将元素取

出，否则说明已到达了集合末尾，停止遍历元素。

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 );

}

}

} 在调用 Iterator 的 next 方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的

next 方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用 next 方法时，迭代器的

索引会指向第二个元素并将该元素返回，依此类推，直到 hasNext 方法返回 false ，表示到达了集合的末尾，终止对

元素的遍历。

2.3 增强 for

增强 for 循环 ( 也称 for each 循环 ) 是 JDK1.5 以后出来的一个高级 for 循环，专门用来遍历数组和集合的。它的内部原

理其实是个 Iterator 迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

格式：

它用于遍历 Collection 和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

练习 1 ：遍历数组

tips: 新 for 循环必须有被遍历的目标。目标只能是 Collection 或者是数组。新式 for 仅仅作为遍历操作出现。

第三章 泛型

3.1 泛型概述

在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升

成 Object 类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

可以把泛型看成未知的数据类型

使用泛型的好处

package com.itheima.demo03.Generic;

import java.util.ArrayList;
import java.util.Iterator;

public class Demo01Generic {
    public static void main(String[] args) {
        show02();
    }

    /*
        创建集合对象,使用泛型
        好处:
            1.避免了类型转换的麻烦,存储的是什么类型,取出的就是什么类型
            2.把运行期异常(代码运行之后会抛出的异常),提升到了编译期(写代码的时候会报错)
         弊端:
            泛型是什么类型,只能存储什么类型的数据
     */
    private static void show02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        //list.add(1);//add(java.lang.String)in ArrayList cannot be applied to (int)

        //使用迭代器遍历list集合
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s+"->"+s.length());
        }
    }

    /*
        创建集合对象,不使用泛型
        好处:
            集合不使用泛型,默认的类型就是Object类型,可以存储任意类型的数据
        弊端:
            不安全,会引发异常
     */
    private static void show01() {
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);

        //使用迭代器遍历list集合
        //获取迭代器
        Iterator it = list.iterator();
        //使用迭代器中的方法hasNext和next遍历集合
        while(it.hasNext()){
            //取出元素也是Object类型
            Object obj = it.next();
            System.out.println(obj);

            //想要使用String类特有的方法,length获取字符串的长度;不能使用  多态 Object obj = "abc";
            //需要向下转型
            //会抛出ClassCastException类型转换异常,不能把Integer类型转换为String类型
            String s = (String)obj;
            System.out.println(s.length());
        }
    }
}

3.3 泛型的定义与使用

引入：

package com.liujinhui.Demo0522Generic;

/*
    定义一个含有泛型的类，模拟ArrayList
    泛型是一个未知的数据结构，不确定什么类型的时候，可以使用泛型
    泛型可以接受任意的数据类型，可以使用Interger、String、Student……
    创建对象的时候确定泛型的类型
 */
public class GenericClass {
    private String name;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

只能是某个确定的类

package com.liujinhui.Demo0522Generic;

public class Demo02GenericClass {
    public static void main(String[] args) {
        GenericClass gc=new GenericClass();
        gc.setName("只能是字符串");
        String name = gc.getName();
        System.out.println(name);

    }
}

更改为泛型类

类名后加E，其他类型改为E

public class GenericClass<E> {
    private E name;
    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

public class Demo02GenericClass {
    public static void main(String[] args) {
        //不写泛型默认为object类型
        GenericClass gc=new GenericClass();
        gc.setName("只能是字符串");
        Object obj = gc.getName();
        //直接打印对象类型报错System.out.println(o);
        //创建Generic对象，泛型使用integer
        GenericClass<Integer> gc2=new GenericClass<>();
        gc2.setName(1);
        Integer name = gc2.getName();
        System.out.println(name);

        //创建GenericClass对象，泛型使用S同日年各类型
        GenericClass<String> gc3=new GenericClass<>();
        gc3.setName("小明");
        String name1 = gc3.getName();
        System.out.println(name1);
    }
}

重点(定义对象时注明泛型)

GenericClass<String> gc3=new GenericClass<>;

含有泛型的方法

package com.liujinhui.Demo0522Generic;

/*
    定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型中间
    格式：
        修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型))｛
            方法体;
        ｝
      含有泛型的方法，在调用方法的时候确定泛型的数据类型
      传递什么类型的参数，反省就是什么类型
 */
public class GenericMethod {
    //定义一个含有泛型的方法
    public <M> void method01(M m){
        System.out.println(m.getClass());
    }
    //定义一个含有泛型的静态方法
    public static <S> void method02(S s){
        System.out.println(s);
    }
}

使用泛型定义的普通方法和静态方法

package com.liujinhui.Demo0522Generic;

/*
    测试含有泛型的方法
 */
public class Demo03GenericMethod {
    //创建GenericMethod对象
    GenericMethod gm=new GenericMethod();
    /*
        调用含有泛型的泛型method
        传递什么类型，泛型就是什么类型
     */
    gm.method01(1);
    gm.method01("刘金辉");
    gm.method01(true);

    //静态方法调用：对象
    gm.method02("静态方法不建议创建对象使用");
    //静态方法可以通过类名.方法名(参数)直接使用
    GenericMethod.method02("你好")
}

ps：静态方法可以直接通过类名调用

定义和使用含有泛型的接口

1、接口实现类指定泛型/接口和实现类均使用抽象泛型，在最后实现测试时再指定泛型的类型

package com.liujinhui.Demo0522Generic;
/*
    定义含有泛型的接口
 */
public interface GenericInterface<I> {
    public abstract void method(I i);
}

接口中有抽象方法，就需要定义类实现接口

即接口的实现类

package com.liujinhui.Demo0522Generic;
import java.util.Iterator;
import java.util.Scanner;
/*
    含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，并指定接口的泛型
    例如：Iterator接口是有泛型的：
    public interface Iterator<E> {
        E next();
    }
    Scanner类实现了Iterator接口并指定接口的泛型为字符串，所以重写的next()方法泛型默认就是字符串
    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);
    }
}

调用方法：

package com.liujinhui.Demo0522Generic;
/*
    测试含有泛型的接口
 */
public class Demo04GenericInterface {
    public static void main(String[] args) {
        //创建GenericInterface对象
        GenericInterfaceImpl1 gi1=new GenericInterfaceImpl1();
        gi1.method("字符串");
    }
}

含有泛型的接口实现方法2

package com.liujinhui.Demo0522Generic;
import java.util.ArrayList;
import java.util.List;
/*
    含有泛型的接口第二种使用方式：接口使用什么泛型，实现类就使用什么泛型
    就相当于定义了一个含有泛型的类，也就是创建对象时定义泛型的类型，例如ArrayList是list的接口
    public interface List<E> extends Collection<E> {
        boolean add(E e);
        E get(int index);
    }
    public class ArrayList<E> extends AbstractList<E> implements List<E>{
           public E get(int index) { }
           public boolean add(E e) { }
    }
 */
public class GenericInterfaceImpl2<I> implements GenericInterface<I>{

    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

调用与测试

package com.liujinhui.Demo0522Generic;
/*
    测试含有泛型的接口
 */
public class Demo04GenericInterface {
    public static void main(String[] args) {
        //创建GenericInterface对象
        GenericInterfaceImpl1 gi1=new GenericInterfaceImpl1();
        gi1.method("字符串");

        //创建GenericInterfaceImp2对象
        GenericInterfaceImpl2<Integer> gi2=new GenericInterfaceImpl2<>();
        gi2.method(3);

        GenericInterfaceImpl2<String> gi3=new GenericInterfaceImpl2<>();
        gi3.method("你好");
    }
}

3.4 泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符 <> 表示。但是一旦使用泛型的通配

符后，只能使用 Object 类中的共性方法，集合中元素自身方法无法使用。

通配符基本使用

泛型的通配符 : 不知道使用什么类型来接收的时候 , 此时可以使用 ?，? 表示未知通配符。

此时只能接受数据 ,不能往该集合中存储数据。

package com.liujinhui.Demo0522Generic;
/*
    泛型的通配符：
        ？：代表任意的数据类型
    使用方式：
        不能创建对象使用
        只能作为方法的参数使用
 */

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);

        ArrayList<String> list02=new ArrayList<>();
        list02.add("nihao");
        //object两个都报错
        //Integer的话list02报错，只能用？
        printArray(list01);
        printArray(list02);
        //定义对象时不能用，参数传递时可以用
        /*ArrayList<?> list03=new ArrayList<>();
        list03.add("a");*/
    }
    /*
        定义一个方法，能够遍历所有类型的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);
        }
    }
}

package com.liujinhui.Demo0522Generic;
import java.util.ArrayList;
import java.util.Collection;
/*
    泛型的上限限定：? extends E 代表使用的泛型只能是E类型的子类/本身
    泛型的下限限定：? super E 代表使用的泛型只能是E的父类/本身
 */
public class Demo06Generic {
    public static void main(String[] args) {
        //只要求能看懂就行
        Collection<Integer> list1 = new ArrayList<Integer>();
        Collection<String> list2 = new ArrayList<String>();
        Collection<Number> list3 = new ArrayList<Number>();
        Collection<Object> list4 = new ArrayList<Object>();
        getElement1(list1);
        getElement1(list2);//报错
        getElement1(list3);
        getElement1(list4);//报错
        getElement2(list1);//报错
        getElement2(list2);//报错
        getElement2(list3);
        getElement2(list4);
        /*
            类与类之间的继承关系
            Integer类 extends Number类 extends Object类
            String类 extends Object类
         */
    }
    // 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
    public static void getElement1(Collection<? extends Number> coll){}
    // 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
    public static void getElement2(Collection<? super Number> coll){}
    }
}

三、泛型的使用

1、泛型类和泛型方法

        类名<泛型>
            方法名(泛型)

2、泛型接口和泛型方法

    接口名<泛型>

    实现接口类名<泛型>

        方法名(泛型)

3、泛型通配符

第四章 集合综合案例

4.1 案例介绍

按照斗地主的规则，完成洗牌发牌的动作。 具体规则：

使用 54 张牌打乱顺序 , 三个玩家参与游戏，三人交替摸牌，每人 17 张牌，最后三张留作底牌。

4.2 案例分析

准备牌：

牌可以设计为一个 ArrayList, 每个字符串为一张牌。 每张牌由花色数字两部分组成，我们可以使用花色

集合与数字集合嵌套迭代完成每张牌的组装。 牌由 Collections 类的 shufflfflffle 方法进行随机排序。

发牌

将每个人以及底牌设计为 ArrayList, 将最后 3 张牌直接存放于底牌，剩余牌通过对 3 取模依次发牌。

看牌

直接打印每个集合。

4.3 代码实现

package com.liujinhui.Demo0522Generic;

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.add("大王");
        poker.add("小王");
        //循环嵌套遍历两个数组，组装52张牌
        for (String number : numbers) {
            //增强式for循环
            for (String color : colors) {
//                System.out.println(color+number);
                //目的：把组装好的牌存放到集合中
                poker.add(color+number);
            }

        }
        //洗牌，使用集合的工具类Collection中的方法
        //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个玩家轮流发牌
            剩余三张给底牌
            注意：
                先判断底牌(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){
                    player01.add(p);
                }else
                    if(i%3==1){
                    player02.add(p);
                }else
                    if (i%3==2){
                        player03.add(p);
                    }
            
        }
        //4、看牌
        System.out.println("刘德华"+player01);
        System.out.println("周润发"+player02);
        System.out.println("周星驰"+player03);
        System.out.println("底牌"+dipai);
    }
}

来自为知笔记(Wiz)