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接口定义着单列集合框架中最最共性的内容。

image.png

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

方法演示：

  1. import java.util.ArrayList;
  2. import java.util.Collection;
  4. public class Demo1Collection {
  5.     public static void main(String[] args) {
  6.         // 创建集合对象
  7.         // 使用多态形式
  8.         Collection<String> coll = new ArrayList<String>();
  9.         // 使用方法
  10.         // 添加功能  boolean  add(String s)
  11.         coll.add("小李广");
  12.         coll.add("扫地僧");
  13.         coll.add("石破天");
  14.         System.out.println(coll);
  16.         // boolean contains(E e) 判断o是否在集合中存在
  17.         System.out.println("判断  扫地僧 是否在集合中"+coll.contains("扫地僧"));
  19.         //boolean remove(E e) 删除在集合中的o元素
  20.         System.out.println("删除石破天："+coll.remove("石破天"));
  21.         System.out.println("操作之后集合中元素:"+coll);
  23.         // size() 集合中有几个元素
  24.         System.out.println("集合中有"+coll.size()+"个元素");
  26.         // Object[] toArray()转换成一个Object数组
  27.         Object[] objects = coll.toArray();
  28.         // 遍历数组
  29.         for (int i = 0; i < objects.length; i++) {
  30.             System.out.println(objects[i]);
  31.         }
  33.         // void  clear() 清空集合
  34.         coll.clear();
  35.         System.out.println("集合中内容为："+coll);
  36.         // boolean  isEmpty()  判断是否为空
  37.         System.out.println(coll.isEmpty());
  38.     }
  39. }

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 集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

Iterator 接口的常用方法如下：

  • public E next():返回迭代的下一个元素。
  • public boolean hasNext():如果仍有元素可以迭代，则返回 true。

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

  1. public class IteratorDemo {
  2.       public static void main(String[] args) {
  3.         // 使用多态方式 创建对象
  4.         Collection<String> coll = new ArrayList<String>();
  6.         // 添加元素到集合
  7.         coll.add("串串星人");
  8.         coll.add("吐槽星人");
  9.         coll.add("汪星人");
  10.         //遍历
  11.         //使用迭代器 遍历   每个集合对象都有自己的迭代器
  12.         Iterator<String> it = coll.iterator();
  13.         //  泛型指的是 迭代出 元素的数据类型
  14.         while(it.hasNext()){ //判断是否有迭代元素
  15.             String s = it.next();//获取迭代出的元素
  16.             System.out.println(s);
  17.         }
  18.       }
  19. }

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

2.2 迭代器的实现原理

我们在之前案例已经完成了 Iterator 遍历集合的整个过程。当遍历集合时，首先通过调用 t 集合的 iterator()方法获得迭代器对象，然后使用 hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用 next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素。

Iterator 迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，为了让初学者能更好地理解迭代器的工作原理，接下来通过一个图例来演示 Iterator 对象迭代元素的过程：image.png

在调用 Iterator 的 next 方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的 next 方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用 next 方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到 hasNext 方法返回 false，表示到达了集合的末尾，终止对元素的遍历。

2.3 增强 for

增强 for 循环(也称 for each 循环)是JDK1.5以后出来的一个高级 for 循环，专门用来遍历数组和集合的。它的内部原理其实是个 Iterator 迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

格式：

  1. for(元素的数据类型  变量 : Collection集合or数组){
  2.       //写操作代码
  3. }

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

练习 1：遍历数组

  1. public class NBForDemo1 {
  2.     public static void main(String[] args) {
  3.         int[] arr = {3,5,6,87};
  4.            //使用增强for遍历数组
  5.         for(int a : arr){//a代表数组中的每个元素
  6.             System.out.println(a);
  7.         }
  8.     }
  9. }

练习 2:遍历集合

  1. public class NBFor {
  2.     public static void main(String[] args) {
  3.         Collection<String> coll = new ArrayList<String>();
  4.         coll.add("小河神");
  5.         coll.add("老河神");
  6.         coll.add("神婆");
  7.         //使用增强for遍历
  8.         for(String s :coll){//接收变量s代表 代表被遍历到的集合元素
  9.             System.out.println(s);
  10.         }
  11.     }
  12. }

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

第四章 集合综合案例

4.1 案例介绍

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

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

image.png

4.2 案例分析

  • 准备牌：
    牌可以设计为一个 ArrayList,每个字符串为一张牌。
    每张牌由花色数字两部分组成，我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。
    牌由 Collections 类的 shuffle 方法进行随机排序。

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

  • 看牌
    直接打印每个集合。

4.3 代码实现

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  4. public class Poker {
  5.     public static void main(String[] args) {
  6.         /*
  7.         * 1: 准备牌操作
  8.         */
  9.         //1.1 创建牌盒 将来存储牌面的
  10.         ArrayList<String> pokerBox = new ArrayList<String>();
  11.         //1.2 创建花色集合
  12.         ArrayList<String> colors = new ArrayList<String>();
  14.         //1.3 创建数字集合
  15.         ArrayList<String> numbers = new ArrayList<String>();
  17.         //1.4 分别给花色 以及 数字集合添加元素
  18.         colors.add("♥");
  19.         colors.add("♦");
  20.         colors.add("♠");
  21.         colors.add("♣");
  23.         for(int i = 2;i<=10;i++){
  24.             numbers.add(i+"");
  25.         }
  26.         numbers.add("J");
  27.         numbers.add("Q");
  28.         numbers.add("K");
  29.         numbers.add("A");
  30.         //1.5 创造牌  拼接牌操作
  31.         // 拿出每一个花色  然后跟每一个数字 进行结合  存储到牌盒中
  32.         for (String color : colors) {
  33.             //color每一个花色
  34.             //遍历数字集合
  35.             for(String number : numbers){
  36.                 //结合
  37.                 String card = color+number;
  38.                 //存储到牌盒中
  39.                 pokerBox.add(card);
  40.             }
  41.         }
  42.         //1.6大王小王
  43.         pokerBox.add("小☺");
  44.         pokerBox.add("大☠");
  45.         // System.out.println(pokerBox);
  46.         //洗牌 是不是就是将  牌盒中 牌的索引打乱
  47.         // Collections类  工具类  都是 静态方法
  48.         // shuffer方法
  49.         /*
  50.          * static void shuffle(List<?> list)
  51.          *     使用默认随机源对指定列表进行置换。
  52.          */
  53.         //2:洗牌
  54.         Collections.shuffle(pokerBox);
  55.         //3 发牌
  56.         //3.1 创建 三个 玩家集合  创建一个底牌集合
  57.         ArrayList<String> player1 = new ArrayList<String>();
  58.         ArrayList<String> player2 = new ArrayList<String>();
  59.         ArrayList<String> player3 = new ArrayList<String>();
  60.         ArrayList<String> dipai = new ArrayList<String>();
  62.         //遍历 牌盒  必须知道索引
  63.         for(int i = 0;i<pokerBox.size();i++){
  64.             //获取 牌面
  65.             String card = pokerBox.get(i);
  66.             //留出三张底牌 存到 底牌集合中
  67.             if(i>=51){//存到底牌集合中
  68.                 dipai.add(card);
  69.             } else {
  70.                 //玩家1   %3  ==0
  71.                 if(i%3==0){
  72.                       player1.add(card);
  73.                 }else if(i%3==1){//玩家2
  74.                       player2.add(card);
  75.                 }else{//玩家3
  76.                       player3.add(card);
  77.                 }
  78.             }
  79.         }
  80.         //看看
  81.         System.out.println("令狐冲："+player1);
  82.         System.out.println("田伯光："+player2);
  83.         System.out.println("绿竹翁："+player3);
  84.         System.out.println("底牌："+dipai);
  85.     }
  86. }