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

主要内容

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

教学目标

第一章 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)