Java Day13

第一章 Collection集合

1.1 集合概述

• 集合：Java中提供的一种容器，可以用来存储多个数据。
• 集合与数组的区别
  • 数组长度是固定的，集合长度是可变的。
  • 数组中存储的是同一类型的元素，可以存储基本数据类型值，集合存储的都是对象，而且对象的类型可以不一致，在开发中一般当对象多的时候，使用集合进行存储。

1.2 集合的框架

JavaSE提供了满足各种需求的API，在使用这些API前，先了解其继承与接口操作架构，才能了解何时采用那一个类，以及类之间如何彼此合作，从而达到灵活应用。

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

• Collection：但李集合类的根接口，用于存储一系列集合符合某种规则的元素，它有两个重要的字接口，分别是java.util.List和java.util.Set。其中 List的特点是元素有序，元素可重复。Set的特点是元素无序，而且不可重复。List接口的主要实现类有java.util.ArrayList和java.util.LinkList，Set接口的主要实现类有java.util.HashSet和java.util.TreeSet。
• 具体结构如下图：

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

代码如下：

/*
* java.util.Collection接口
*   所有单列集合最顶层的接口，里边定义 了所有单列集合共性的方法。
*   注意：任意的单列集合都可以使用Collection接口中的方法。
*
* 共性的方法：
*   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<>();
        System.out.println(coll);  // 重写了toString方法 []

        /*
        * public boolean add(E e)：把给定的对象添加到当前集合中。
        * 返回值是一个boolean值，一般都返回true，所以可以不用接收。
        * */
        boolean b1 = coll.add("tiger");
        System.out.println(b1);  // true
        System.out.println(coll);  // [tiger]
        coll.add("trony");
        coll.add("hhhhh");
        System.out.println(coll);  // [tiger, trony, hhhhh]

        /*
        * pubilc boolean remove(E e)：把给定的对象在当前集合中删除。
        * 返回值是一个boolean值，集合中存在元素，删除元素，返回true
        *                     集合中不存在元素，删除失败，返回false
        *
        * */
        boolean b2 = coll.remove("hhhhh");
        System.out.println("b2:" + b2);

        boolean b3 = coll.remove("hihih");
        System.out.println("b3:" + b3);

        System.out.println(coll);  // [tiger, trony]

        /*
        * public boolean contains(E a)：判断当前集合中是否包含给定的对象。
        * 包含返回true
        * 不包含返回false
        * */
        boolean b4 = coll.contains("trony");
        System.out.println("b4:" + b4);  // true

        boolean b5 = coll.contains("haoifhdo");
        System.out.println("b5:" + b5);  // false

        // public boolean isEmpty()：判断当前集合是否为空。
        boolean b6 = coll.isEmpty();
        System.out.println(b6);

        // public int size()：返回集合中元素的个数。
        int size = coll.size();
        System.out.println(size);  // 2

        // public Object[] toArray()：把集合中的元素，存储到数组中。
        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        // public void clear()：清空集合中所有的元素。但是不删除集合，集合还在
        coll.clear();
        System.out.println(coll);
        System.out.println(coll.isEmpty());
    }
}

第二章 迭代器

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。
• 代码如下：

package com.it.day02code.demo02.Iterator;

/*
* java.util.Iterator接口：迭代器（对集合进行遍历）
* 有两个常用方法：
*   boolean hasNext()：判断集合中还有没有下一个元素，有就返回true，没有就返回false
*   E next()：取出集合中的下一个元素
*
* Iterator迭代器，是一个接口，我们无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊
* Collection接口中有一个方法，叫iterator()，这个方法返回的就是迭代器的实现类对象。
*   Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。
* 迭代器的使用步骤：
*   1、使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收(多态)。
*   2、使用Iterator接口中的方法hasNext()判断还有没有下一个元素。
*   3、使用Iterator接口中的方法next取出集合中的下一个元素。
*
* */

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("tiger");
        coll.add("trony");
        coll.add("hahaha");

        /*
        * 1、使用集合中的方法iterator()获取迭代器的实现类对象，使用Iteraator接口接收（多态）
        * 注意：
        *   Iterator<E>接口也是有泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型
        * */
        // 多态  接口           实现类对象
        Iterator<String> it = coll.iterator();

        // 使用Iterator接口中的方法hasNext判断还有没有下一个元素
//        boolean b = it.hasNext();
//        System.out.println(b);  // true
//        // 使用Iterator接口中的方法next取出集合中的下一个元素
//        String s = it.next();
//        System.out.println(s);
//
//        b = it.hasNext();
//        System.out.println(b);
//        s = it.next();
//        System.out.println(s);
//
//        b = it.hasNext();
//        System.out.println(b);
//        s = it.next();
//        System.out.println(s);
//
//        b = it.hasNext();
//        System.out.println(b);
//        s = it.next();
//        System.out.println(s);
//
//        b = it.hasNext();
//        System.out.println(b);
//        // 没有元素就会抛出NoSachElementexception异常
//        // s = it.next();

        // 使用循环优化迭代器取出元素的代码
        while(it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println("=========================");

        for (Iterator<String> it2 = coll.iterator(); it2.hasNext();) {
            System.out.println(it2.next());
        }


    }

}

2.2 迭代器的实现原理

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

Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，工作原理如下：

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

2.3 增强for

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

代码如下：

package com.it.day02code.demo02.Iterator;

/*
* 增强for循环：底层使用的也是迭代器，使用for循环的格式，简化了迭代器的书写。
* 是JDK1.5之后出现的新特性
* Collection<E> extends Iterable<E>：所有的单列集合都可以使用增强for
* public interface Iterable<T> 实现这个接口允许对象成为 "foreach" 语句的目标
*
* 增强for循环：用来遍历集合和数组
*
* 格式：
*   for(集合/数组的数据类型 变量名; 集合名/数组名) {
*       sout(变量名);
*   }
*
* 注意：增强for循环必须有遍历的目标，目标必须是数组或集合
* */

import java.util.ArrayList;

public class Demo02Foreach {
    public static void main(String[] args) {
        // demo01();
        demo02();
    }

    private static void demo02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");
        for (String s : list) {
            System.out.println(s);
        }
    }

    // 使用增强for循环遍历数组
    private static void demo01() {
        int[] arr = {1, 2, 3, 4, 5};
        for(int i : arr) {
            System.out.println(i);
        }
    }


}

第三章 泛型

3.1 泛型概述

在前面学习集合的时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们就会被提升成为Object类型，当我们取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

请看下面代码：

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

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

    }

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

        // 使用迭代器遍历集合
        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获取字符串的长度：不能使用 多态
            // 需要向下转型
            // 会抛出ClassCastException类型转换异常，不能把Integer类型转换为String类型。
            // String s = (String)obj;
            // System.out.println(s.length());

       }
    }


}

程序在运行时发生了问题java.lang.ClassException。这时由于集合中什么类型元素都可以存储。导致取出时强转引发运行时，ClassCastException。虽然Collection可以存储各种对象，但实际上通常Collection只存储同一类型的对象。因此，在JDK5之后增加了泛型语法，让我们在设计API的时候可以指定类或方法支持泛型，这样我们使用API也变得更为简洁，并得到了编译时期的语法检查。

• 泛型：可以在类或方法中预支的使用未知的类型。

3.2 使用泛型的好处

• 将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
• 避免了类型强转。

代码如下：

package com.it.day02code.demo03.Generic;

public class Demo02GenericClass {
    public static void main(String[] args) {
        // 不写泛型默认为object类型
        GenericClass gc = new GenericClass();
        gc.setName("tiger");
        Object obj = gc.getName();

        // 创建GenericClass对象，泛型使用Integer类型
        GenericClass<Integer> gc2 = new GenericClass<>();
        gc2.setName(1);

        Integer name = gc2.getName();
        System.out.println(name);



    }
}

3.3 泛型的定义与使用

泛型，用来灵活的将数据类型应用到不同的类，方法，接口当中。将数据类型作为参数传递。

3.3.1 定义和使用含有泛型的类

• 定义格式：

修饰符 class 类名<代表泛型的变量> {}

• 例如：

class ArrayList<E> {
    public boolean add(E e) {}

    public E get(int index) {}
    
    ...

}

• 代码如下：

定义一个泛型类：

/*
* 定义一个含有泛型的类，模拟ArrayList集合
* 泛型是一个未知的数据类型，当我们不确定是什么数据类型的时候，可以使用泛型
* 泛型可以接收任意的数据类型
* 创建对象的时候确定泛型的数据类型
*
* */

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("tiger");
        Object obj = gc.getName();

        // 创建GenericClass对象，泛型使用Integer类型
        GenericClass<Integer> gc2 = new GenericClass<>();
        gc2.setName(1);

        Integer name = gc2.getName();
        System.out.println(name);



    }
}

3.3.2 含有泛型的方法

• 定义格式

修饰符 <代表泛型的变量> 返回值类型 方法名(参数) { }

• 代码如下：

package com.it.day02code.demo03.Generic;

/*
* 测试含有泛型的方法
* */

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("静态方法不建议创建对象使用");

        // 静态方法，通过类名.方法名(参数)可以直接使用
        GenericMethod.method02("静态方法");
        GenericMethod.method02(1);

    }
}

3.3.3 含有泛型的接口

• 定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数) {  }

• 代码如下：

定义含有泛型的接口：

package com.it.day02code.demo03.Generic;

/*
* 定义含有泛型的接口
*
* */

public interface GenericInterface<I> {
    public abstract void method(I i);
}

定义实现类的第一种方式：

/*
* 含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型。
*
* */

public class GenericInterfaceImpl implements GenericInterface<String> {

    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

定义实现类的第二种方式：

/*
* 含有泛型的接口第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
* 就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类
*
* */

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) {
        // 创建GenericInterfaceImpl对象
        GenericInterfaceImpl gi1 = new GenericInterfaceImpl();
        gi1.method("string");

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

        GenericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>();
        gi3.method(8.8);
    }
}

3.4 泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示，但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身的方法无法使用。

3.4.1 通配符的基本使用

泛型的通配符：不知道使用什么类型来接收的时候，鄙视可以使用“ ？”，“ ？”表示未知通配符。

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

例如：

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


    }

    /*
    * 定义一个方法，能遍历所有类型的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);
        }
    }

}

3.4.2 通配符的高级使用——受限泛型

在前面我们设置泛型的时候，实际上是任意设置的，只要是类就可以设置，但是在Java的泛型中可以指定一个泛型的上下限。

泛型的上限：

• 格式：类型名称<? extends 类 > 对象名称
• 意义：只能接收该类型及其子类。

泛型的下限：

• 格式：类型名称<? super 类> 对象名称
• 意义：只能接收该类型及其父类。

第四章 集合综合案例

4.1 案例介绍

按照斗地主的规则，完成洗牌发牌的动作，具体规则：使用54张牌打乱顺序，三个玩家参与游戏，三人交替摸牌，没人17张牌，最后三张留作底牌。

4.1 代码实现

import java.util.ArrayList;
import java.util.Collections;

public class FightLordMain {
    public static void main(String[] args) {
        String[] flower = {"♥️", "♦️", "♣️", "♠️"};
        String[] number = {"2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3"};
        ArrayList<String> squeezers = new ArrayList<>();
        for (int i = 0; i < flower.length; i++) {
            for (int j = 0; j < number.length; j++) {
                String squeezer = flower[i] + number[j];
                squeezers.add(squeezer);
            }
        }
        squeezers.add("大王");
        squeezers.add("小王");
        Collections.shuffle(squeezers);

        ArrayList<String> p1 = new ArrayList<>();
        ArrayList<String> p2 = new ArrayList<>();
        ArrayList<String> p3 = new ArrayList<>();
        ArrayList<String> cards = new ArrayList<>();

        for (int i = 1; i < 4; i++) {
            cards.add(squeezers.get(squeezers.size()-i));
        }
        for (int i = 0; i < squeezers.size() - 3; i++) {
            if(i % 3 == 0) {
                p1.add(squeezers.get(i));
            } else if (i % 3 == 1) {
                p2.add(squeezers.get(i));
            } else if (i % 3 == 2) {
                p3.add(squeezers.get(i));
            }
        }
        System.out.println(p1.toString());
        System.out.println(p2.toString());
        System.out.println(p3.toString());
        System.out.println(cards);
    }
}