【Java学习笔记】集合

前言

• 该文章为Java自学笔记：集合
• 学习视频为https://www.bilibili.com/video/av250694651

集合的概述

集合和数组都是容器。

数组的特点：

• 数组定义完成并启动后，类型确定、长度固定。
• 适合元素个数和类型确定的场景，不适合做需要增删数据的操作。

集合的特点：

• 集合的大小不固定，启动后可以动态变化，类型也可以选择不固定。
• 集合非常适合做元素的增删操作。

总结：
1、数组和集合的元素存储的个数问题。

• 数组定义后类型确定，长度固定
• 集合类型可以不固定，大小是可变的。

2、数组和集合存储元素的类型问题。

• 数组可以存储基本类型和引用类型的数据。
• 集合只能存储引用数据类型的数据。

3、数组和集合适合的场景

• 数组适合做数据个数和类型确定的场景。
• 集合适合做数据个数不确定，且要做增删元素的场景。

集合的体系特点

集合类体系结构

• Collection单列集合，每个元素（数据）只包含一个值。
• Map双列集合，每个元素包含两个值（键值对）。

Collection集合体系：

Collection集合特点：

• List系列集合：添加的元素是有序、可重复、有索引。
  • ArrayList、LinkedList：有序、可重复、有索引。
• Set系列集合：添加的元素是无序、不重复、无索引。
  • HashSet：无序、不重复、无索引。
  • LinkedHashSet：有序、不重复、无索引。
  • TreeSet：按照大小默认升序排列、不重复、无索引。

集合对于泛型的支持：集合都是支持泛型的，可以在编译阶段约束集合只能操作某种数据类型。

Collection<String> lists = new ArrayList<String>();
Collection<String> lists = new ArrayList<>(); // JDK 1.7开始后面的泛型类型申明可以省略不写

注意：集合和泛型都只能支持引用数据类型，不支持基本数据类型，所以集合中存储的元素都认为是对象。

// 存储基本类型使用包装类
Collection<Integer> lists = new ArrayList<>();
Collection<Double> lists = new ArrayList<>();

Collection的常用方法

Collection集合是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的。
Collection常用API：

方法名称	说明
public boolean add(E e)	把给定的对象添加到当前集合中
public void clear()	清空集合中所有的元素
public boolean remove(E e)	把给定的对象在当前集合中删除
public boolean contains(Object obj)	判断当前集合中是否包含给定的对象
public boolean isEmpty()	判断当前集合是否为空
public int size()	返回集合中元素的个数。
public Object[] toArray()	把集合中的元素，存储到数组中

Collection集合的遍历方式

方式一：迭代器

迭代器遍历概述：

• 遍历就是一个一个把容器中的元素访问一遍。
• 迭代器在Java中的代表是Iterator，迭代器是集合的专用遍历方式。

Collection集合获取迭代器：

方法名称	说明
Iterator iterator()	返回集合中的迭代器对象，该迭代器对象默认指向当前集合的0索引

Iterator中的常用方法：

方法名称	说明
boolean hasNext()	询问当前位置是否有元素存在，存在返回true ,不存在返回false
E next()	获取当前位置的元素，并同时将迭代器对象移向下一个位置，注意防止取出越界。

public class CollectionDemo01 {
    public static void main(String[] args) {
        ArrayList<String> lists = new ArrayList<>();
        lists.add("李一");
        lists.add("李二");
        lists.add("李三");
        lists.add("李四");
        System.out.println(lists);
        System.out.println("------------------------------------------");
        Iterator<String> it = lists.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

方式二：foreach/增强for循环

增强for循环： 既可以遍历集合也可以遍历数组。

Collection<String> list = new ArrayList<>();
...
for(String ele : list) {
	System.out.println(ele);
}

方式三：lambda表达式

Lambda表达式遍历集合： 得益于JDK 8开始的新技术Lambda表达式，提供了一种更简单、更直接的遍历集合的方式。

Collection结合Lambda遍历的API：

方法名称	说明
default void forEach(Consumer<? super T> action)	结合lambda遍历集合

public class CollectionDemo01 {
    public static void main(String[] args) {
        ArrayList<String> lists = new ArrayList<>();
        lists.add("李一");
        lists.add("李二");
        lists.add("李三");
        lists.add("李四");
        System.out.println(lists);
        System.out.println("------------------------------------------");
        lists.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        System.out.println("------------------------------------------");
        lists.forEach(s -> System.out.println(s));
    }
}

Collection集合存储自定义类型的对象

public class TestDemo {
    public static void main(String[] args) {
        // 1、定义一个电影类
        // 2、定义一个集合对象存储3部电影对象
        Collection<Movie> movies = new ArrayList<>();
        movies.add(new Movie("《你好，李焕英》", 9.5, "张小斐,贾玲,沈腾,陈赫"));
        movies.add(new Movie("《唐人街探案》", 8.5, "王宝强,刘昊然,美女"));
        movies.add(new Movie("《刺杀小说家》",8.6, "雷佳音,杨幂"));

        System.out.println(movies);

        // 3、遍历集合容器中的每个电影对象
        for (Movie movie : movies) {
            System.out.println("片名：" + movie.getName());
            System.out.println("得分：" + movie.getScore());
            System.out.println("主演：" + movie.getActor());
        }
    }
}

内存图演示：

集合中存储的是元素对象的地址。

常见数据结构

数据结构概述

数据结构概述：

• 数据结构是计算机底层存储、组织数据的方式。是指数据相互之间是以什么方式排列在一起的。
• 通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。

常见的数据结构：
堆、栈、数组、链表、二叉树、二叉查找树、平衡二叉树、红黑树…

数组

链表

二叉树、 二叉查找树

平衡二叉树

红黑树

红黑树概述

• 红黑树是一种自平衡的二叉查找树，是计算机科学中用到的一种数据结构。
• 1972年出现，当时被称之为平衡二叉B树。1978年被修改为如今的"红黑树"。
• 每一个节点可以是红或者黑；红黑树不是通过高度平衡的，它的平衡是通过“红黑规则”进行实现的。
  
  红黑规则：
• 每一个节点或是红色的，或者是黑色的，根节点必须是黑色。
• 如果某一个节点是红色，那么它的子节点必须是黑色(不能出现两个红色节点相连的情况)。
• 对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点。

添加节点：

• 添加的节点的颜色，可以是红色的，也可以是黑色的。
• 默认用红色效率高。

添加规则：

• 父节点为黑色：不需要做任何操作。
• 父节点为红色，叔叔节点也是红色：
  1. 将“父节点”设为黑色，将“叔叔节点”设为黑色
  2. 将“祖父节点”设为“红色”。
  3. 如果祖父节点为根节点，则将根节点再次变成黑色。
• 父节点为红色，叔叔节点也是黑色：
  1. 将“父节点”设为“黑色”
  2. 将“祖父节点”设为“红色”。
  3. 以祖父节点为支点进行旋转

红黑树小结：

• 红黑树不是高度平衡的，它的平衡是通过"红黑规则"进行实现的

规则如下：

• 每一个节点或是红色的，或者是黑色的，根节点必须是黑色。
• 如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为Nil，这些Nil视为叶节点，每个叶节点(Nil)是黑色的；
• 如果某一个节点是红色，那么它的子节点必须是黑色(不能出现两个红色节点相连的情况)
• 对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点。

红黑树增删改查的性能都很好

各种数据结构的特点和作用小结：

• 队列：先进先出，后进后出。
• 栈：后进先出，先进后出。
• 数组：内存连续区域，查询快，增删慢。
• 链表：元素是游离的，查询慢，首尾操作极快。
• 二叉树：永远只有一个根节点, 每个结点不超过2个子节点的树。
• 查找二叉树：小的左边，大的右边，但是可能树很高，查询性能变差。
• 平衡查找二叉树：让树的高度差不大于1，增删改查都提高了。
• 红黑树（就是基于红黑规则实现了自平衡的排序二叉树）

List系列集合

List集合特点、特有API

List系列集合特点

• ArrayList、LinekdList ：有序，可重复，有索引。
• 有序：存储和取出的元素顺序一致
• 有索引：可以通过索引操作元素
• 可重复：存储的元素可以重复

List集合特有方法：List集合因为支持索引，所以多了很多索引操作的独特api，其他Collection的功能List也都继承了。

方法名称	说明
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

List的实现类的底层原理

• ArrayList底层是基于数组实现的，根据查询元素快，增删相对慢。
• LinkedList底层基于双链表实现的，查询元素慢，增删首尾元素是非常快的。

List集合的遍历方式小结

List集合的遍历方式有几种：

1. 迭代器
2. 增强for循环
3. Lambda表达式
4. for循环（因为List集合存在索引）

public class ListDemo {
    public static void main(String[] args) {
        List<String> lists = new ArrayList<>();
        lists.add("java1");
        lists.add("java2");
        lists.add("java3");

        /** （1）for循环。 */
        System.out.println("-----------------------");
        for (int i = 0; i < lists.size(); i++) {
            String ele = lists.get(i);
            System.out.println(ele);
        }


        /** （2）迭代器。 */
        System.out.println("-----------------------");
        Iterator<String> it = lists.iterator();
        while (it.hasNext()){
            String ele = it.next();
            System.out.println(ele);
        }

        /** （3）foreach */
        System.out.println("-----------------------");
        for (String ele : lists) {
            System.out.println(ele);
        }

        /** （4）JDK 1.8开始之后的Lambda表达式  */
        System.out.println("-----------------------");
        lists.forEach(s -> {
            System.out.println(s);
        });
    }
}

ArrayList集合的底层原理

• ArrayList底层是基于数组实现的：根据索引定位元素快，增删需要做元素的移位操作。
• 第一次创建集合并添加第一个元素的时候，在底层创建一个默认长度为10的数组。

List集合存储的元素要超过容量怎么办？

• 1.5倍扩容，并迁移数据。

LinkedList集合的底层原理

LinkedList的特点： 底层数据结构是双链表，查询慢，首尾操作的速度是极快的，所以多了很多首尾操作的特有API。

LinkedList集合的特有功能：

方法名称	说明
public void addFirst​(E e)	在该列表开头插入指定的元素
public void addLast​(E e)	将指定的元素追加到此列表的末尾
public E getFirst​()	返回此列表中的第一个元素
public E getLast​()	返回此列表中的最后一个元素
public E removeFirst​()	从此列表中删除并返回第一个元素
public E removeLast​()	从此列表中删除并返回最后一个元素

补充知识：集合的并发修改异常问题

问题引出

• 当我们从集合中找出某个元素并删除的时候可能出现一种并发修改异常问题。

哪些遍历存在问题？

• 迭代器遍历集合且直接用集合删除元素的时候可能出现。
• 增强for循环遍历集合且直接用集合删除元素的时候可能出现。

哪种遍历且删除元素不出问题

• 迭代器遍历集合但是用迭代器自己的删除方法操作可以解决。
• 使用for循环遍历并删除元素不会存在这个问题。

public class Test {
    public static void main(String[] args) {
        // 1、准备数据
        ArrayList<String> list = new ArrayList<>();
        list.add("黑马");
        list.add("Java");
        list.add("Java");
        list.add("赵敏");
        list.add("赵敏");
        list.add("素素");
        System.out.println(list);
        // [黑马, Java, Java, 赵敏, 赵敏, 素素]
        //        it

        // 需求：删除全部的Java信息。
        // a、迭代器遍历删除
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String ele = it.next();
            if("Java".equals(ele)){
                // 删除Java
                // list.remove(ele); // 集合删除会出毛病
                it.remove(); // 删除迭代器所在位置的元素值（没毛病）
            }
        }
        System.out.println(list);

        // b、foreach遍历删除 (会出现问题，这种无法解决的，foreach不能边遍历边删除，会出bug)
        for (String s : list) {
            if("Java".equals(s)){
                list.remove(s);
            }
        }

        // c、lambda表达式(会出现问题，这种无法解决的，Lambda遍历不能边遍历边删除，会出bug)
        list.forEach(s -> {
            if("Java".equals(s)){
                list.remove(s);
            }
        });

        // d、for循环(边遍历边删除集合没毛病，但是必须从后面开始遍历删除才不会出现漏掉应该删除的元素)
        for (int i = list.size() - 1; i >= 0 ; i--) {
            String ele = list.get(i);
            if("Java".equals(ele)){
                list.remove(ele);
            }
        }
        System.out.println(list);
    }
}

补充知识：泛型深入

泛型的概述和优势

泛型概述：是JDK5中引入的特性，可以在编译阶段约束操作的数据类型，并进行检查。

• 泛型的格式：<数据类型>; 注意：泛型只能支持引用数据类型。
• 集合体系的全部接口和实现类都是支持泛型的使用的。

泛型的好处：

• 统一数据类型。
• 把运行时期的问题提前到了编译期间，避免了强制类型转换可能出现的异常，因为编译阶段类型就能确定下来。

泛型可以在很多地方进行定义:
类后面（泛型类）
方法申明上（泛型方法）
接口后面（泛型接口）

自定义泛型类

泛型类的概述

• 定义类时同时定义了泛型的类就是泛型类。
• 泛型类的格式：修饰符 class 类名<泛型变量>{ }

范例：public class MyArrayList< T> { }
此处泛型变量T可以随便写为任意标识，常见的如E、T、K、V等。
作用：编译阶段可以指定数据类型，类似于集合的作用。

自定义泛型方法

泛型方法的概述

• 定义方法时同时定义了泛型的方法就是泛型方法。
• 泛型方法的格式：修饰符 <泛型变量> 方法返回值 方法名称(形参列表){}

范例： public < T> void show(T t) { }
作用：方法中可以使用泛型接收一切实际类型的参数，方法更具备通用性。

自定义泛型接口

泛型接口的概述

• 使用了泛型定义的接口就是泛型接口。
• 泛型接口的格式：修饰符 interface 接口名称<泛型变量>{}

范例： public interface Data< E>{}
作用：泛型接口可以让实现类选择当前功能需要操作的数据类型

泛型通配符、上下限

通配符:?

• ? 可以在“使用泛型”的时候代表一切类型。
• E T K V 是在定义泛型的时候使用的。

泛型的上下限：

• ? extends Car: ?必须是Car或者其子类 泛型上限
• ? super Car ： ?必须是Car或者其父类 泛型下限

public class GenericDemo {
    public static void main(String[] args) {
        ArrayList<BMW> bmws = new ArrayList<>();
        bmws.add(new BMW());
        bmws.add(new BMW());
        bmws.add(new BMW());
        go(bmws);

        ArrayList<BENZ> benzs = new ArrayList<>();
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        go(benzs);

        ArrayList<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog());
        dogs.add(new Dog());
        dogs.add(new Dog());
        // go(dogs);
    }

    /**
       所有车比赛
     */
    public static void go(ArrayList<? extends Car> cars){
    }
}

class Dog{
}

class BENZ extends Car{
}

class BMW extends Car{
}

// 父类
class Car{
}

注意：
虽然BMW和BENZ都继承了Car
但是ArrayList< BMW>和ArrayList< BENZ>与ArrayList< Car>没有关系的！!

Set系列集合

Set系列集系概述

Set系列集合特点

• 无序：存取顺序不一致
• 不重复：可以去除重复
• 无索引：没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素。

Set集合实现类特点

• HashSet : 无序、不重复、无索引。
• LinkedHashSet：有序、不重复、无索引。
• TreeSet：排序、不重复、无索引。

Set集合的功能上基本上与Collection的API一致。

HashSet元素无序的底层原理：哈希表

HashSet底层原理

• HashSet集合底层采取哈希表存储的数据。
• 哈希表是一种对于增删改查数据性能都较好的结构。

哈希表的组成

• JDK8之前的，底层使用数组+链表组成
• JDK8开始后，底层采用数组+链表+红黑树组成。

在了解哈希表之前需要先理解哈希值的概念：
哈希值：是JDK根据对象的地址，按照某种规则算出来的int类型的数值。

Object类的API

• public int hashCode()：返回对象的哈希值

对象的哈希值特点

• 同一个对象多次调用hashCode()方法返回的哈希值是相同的
• 默认情况下，不同对象的哈希值是不同的。

HashSet1.7版本原理解析：数组 + 链表 +（结合哈希算法）

1. 创建一个默认长度16的数组，数组名table
2. 根据元素的哈希值跟数组的长度求余计算出应存入的位置（哈希算法）
3. 判断当前位置是否为null，如果是null直接存入
4. 如果位置不为null，表示有元素，则调用equals方法比较
5. 如果一样，则不存，如果不一样，则存入数组，
   • JDK 7新元素占老元素位置，指向老元素
   • JDK 8中新元素挂在老元素下面

JDK1.8版本HashSet原理解析

• 底层结构：哈希表（数组、链表、红黑树的结合体）
• 当挂在元素下面的数据过多时，查询性能降低，从JDK8开始后，当链表长度超过8的时候，自动转换为红黑树。

结论：JDK8开始后，哈希表对于红黑树的引入进一步提高了操作数据的性能。

哈希表详细流程

1. 创建一个默认长度16，默认加载因为0.75的数组，数组名table
2. 根据元素的哈希值跟数组的长度计算出应存入的位置
3. 判断当前位置是否为null，如果是null直接存入，如果位置不为null，表示有元素， 则调用equals方法比较属性值，如果一样，则不存，如果不一样，则存入数组。
4. 当数组存满到16*0.75=12时，就自动扩容，每次扩容原先的两倍

HashSet元素去重复的底层原理

1. 创建一个默认长度16的数组，数组名table
2. 根据元素的哈希值跟数组的长度求余计算出应存入的位置（哈希算法）
3. 判断当前位置是否为null，如果是null直接存入
4. 如果位置不为null，表示有元素，则调用equals方法比较
5. 如果一样，则不存，如果不一样，则存入数组，

结论：如果希望Set集合认为2个内容一样的对象是重复的，必须重写对象的hashCode()和equals()方法

实现类：LinkedHashSet

LinkedHashSet集合概述和特点

• 有序、不重复、无索引。
• 这里的有序指的是保证存储和取出的元素顺序一致
• 原理：底层数据结构是依然哈希表，只是每个元素又额外的多了一个双链表的机制记录存储的顺序。
  

实现类：TreeSet

TreeSet集合概述和特点

• 不重复、无索引、可排序
• 可排序：按照元素的大小默认升序（有小到大）排序。
• TreeSet集合底层是基于红黑树的数据结构实现排序的，增删改查性能都较好。
• 注意：TreeSet集合是一定要排序的，可以将元素按照指定的规则进行排序。

TreeSet集合默认的规则

• 对于数值类型：Integer , Double，官方默认按照大小进行升序排序。
• 对于字符串类型：默认按照首字符的编号升序排序。
• 对于自定义类型如Student对象，TreeSet无法直接排序。

结论：想要使用TreeSet存储自定义类型，需要制定排序规则

自定义排序规则

• TreeSet集合存储对象的的时候有2种方式可以设计自定义比较规则

方式一

• 让自定义的类（如学生类）实现Comparable接口重写里面的compareTo方法来定制比较规则。

方式二

• TreeSet集合有参数构造器，可以设置Comparator接口对应的比较器对象，来定制比较规则。

两种方式中，关于返回值的规则：

• 如果认为第一个元素大于第二个元素返回正整数即可。
• 如果认为第一个元素小于第二个元素返回负整数即可。
• 如果认为第一个元素等于第二个元素返回0即可，此时Treeset集合只会保留一个元素，认为两者重复。

public class SetDemo5 {
    public static void main(String[] args) {
        Set<Integer> sets = new TreeSet<>(); // 不重复 无索引 可排序
        sets.add(23);
        sets.add(24);
        sets.add(12);
        sets.add(8);
        System.out.println(sets);

        Set<String> sets1 = new TreeSet<>(); // 不重复 无索引 可排序
        sets1.add("Java");
        sets1.add("Java");
        sets1.add("angela");
        sets1.add("黑马");
        sets1.add("Java");
        sets1.add("About");
        sets1.add("Python");
        sets1.add("UI");
        sets1.add("UI");
        System.out.println(sets1);

        System.out.println("------------------------------");
        // 方式二：集合自带比较器对象进行规则定制
        //
//        Set<Apple> apples = new TreeSet<>(new Comparator<Apple>() {
//            @Override
//            public int compare(Apple o1, Apple o2) {
//                // return o1.getWeight() - o2.getWeight(); // 升序
//                // return o2.getWeight() - o1.getWeight(); // 降序
//                // 注意：浮点型建议直接使用Double.compare进行比较
//                // return Double.compare(o1.getPrice() , o2.getPrice()); // 升序
//                return Double.compare(o2.getPrice() , o1.getPrice()); // 降序
//            }
//        });

        Set<Apple> apples = new TreeSet<>(( o1,  o2) ->  Double.compare(o2.getPrice() , o1.getPrice())  );
        apples.add(new Apple("红富士", "红色", 9.9, 500));
        apples.add(new Apple("青苹果", "绿色", 15.9, 300));
        apples.add(new Apple("绿苹果", "青色", 29.9, 400));
        apples.add(new Apple("黄苹果", "黄色", 9.8, 500));
        System.out.println(apples);
    }
}

注意：如果TreeSet集合存储的对象有实现比较规则，集合也自带比较器，默认使用集合自带的比较器排序。

Collection体系的特点、使用场景总结

如果希望元素可以重复，又有索引，索引查询要快？

• 用ArrayList集合，基于数组的。（用的最多）

如果希望元素可以重复，又有索引，增删首尾操作快？

• 用LinkedList集合，基于链表的。

如果希望增删改查都快，但是元素不重复、无序、无索引。

• 用HashSet集合，基于哈希表的。

如果希望增删改查都快，但是元素不重复、有序、无索引。

• 用LinkedHashSet集合，基于哈希表和双链表。

如果要对对象进行排序。

• 用TreeSet集合，基于红黑树。后续也可以用List集合实现排序

补充知识：可变参数

可变参数

• 可变参数用在形参中可以接收多个数据。
• 可变参数的格式：数据类型…参数名称

可变参数的作用

• 传输参数非常灵活，方便。可以不传输参数，可以传输1个或者多个，也可以传输一个数组
• 可变参数在方法内部本质上就是一个数组。

可变参数的注意事项：

• 1.一个形参列表中可变参数只能有一个
• 2.可变参数必须放在形参列表的最后面

public class MethodDemo {
    public static void main(String[] args) {

        sum(); // 1、不传参数
        sum(10); // 2、可以传输一个参数
        sum(10, 20, 30); // 3、可以传输多个参数
        sum(new int[]{10, 20, 30, 40, 50}); // 4、可以传输一个数组
    }

    /**
       注意：一个形参列表中只能有一个可变参数,可变参数必须放在形参列表的最后面
     * @param nums
     */
    public static void sum(  int...nums){
        // 注意：可变参数在方法内部其实就是一个数组。 nums
        System.out.println("元素个数：" + nums.length);
        System.out.println("元素内容：" + Arrays.toString(nums));
    }
}

补充知识：集合工具类Collections

Collections集合工具类

• java.utils.Collections:是集合工具类
• 作用：Collections并不属于集合，是用来操作集合的工具类。

Collections常用的API

方法名称	说明
public static < T> boolean addAll(Collection<? super T> c, T… elements)	给集合对象批量添加元素
public static void shuffle(List<?> list)	打乱List集合元素的顺序

Collections排序相关API

• 使用范围：只能对于List集合的排序。

排序方式1

方法名称	说明
public static < T> void sort(List< T> list)	将集合中元素按照默认规则排序

注意：本方式不可以直接对自定义类型的List集合排序，除非自定义类型实现了比较规则Comparable接口。

排序方式2

方法名称	说明
public static < T> void sort(List< T> list，Comparator<? super T> c)	将集合中元素按照指定规则排序

Collection体系的综合案例

public class GameDemo {
    /**
      1、定义一个静态的集合存储54张牌对象
     */
     public static List<Card> allCards = new ArrayList<>();

    /**
      2、做牌：定义静态代码块初始化牌数据
     */
    static {
        // 3、定义点数：个数确定，类型确定，使用数组
        String[] sizes = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        // 4、定义花色：个数确定，类型确定，使用数组
        String[] colors = {"♠", "♥", "♣", "♦"};
        // 5、组合点数和花色
        int index = 0; // 记录牌的大小
        for (String size : sizes) {
            index++;
            for (String color : colors) {
                // 6、封装成一个牌对象。
                Card c = new Card(size, color, index);
                // 7、存入到集合容器中去
                allCards.add(c);
            }
        }
        // 8 大小王存入到集合对象中去 "👲" , "🃏"
        Card c1 = new Card("" ,  "🃏", ++index);
        Card c2 = new Card("" ,  "👲",++index);
        Collections.addAll(allCards , c1 , c2);
        System.out.println("新牌：" + allCards);
    }

    public static void main(String[] args) {
        // 9、洗牌
        Collections.shuffle(allCards);
        System.out.println("洗牌后：" + allCards);

        // 10、发牌（定义三个玩家，每个玩家的牌也是一个集合容器）
        List<Card> linhuchong = new ArrayList<>();
        List<Card> jiumozhi = new ArrayList<>();
        List<Card> renyingying = new ArrayList<>();

        // 11、开始发牌（从牌集合中发出51张牌给三个玩家，剩余3张作为底牌）
        // allCards = [🃏, A♠, 5♥, 2♠, 2♣, Q♣, 👲, Q♠ ...
        //    i        0  1   2   3   4   5    6  7      %  3
        for (int i = 0; i < allCards.size() - 3; i++) {
            // 先拿到当前牌对象
            Card c = allCards.get(i);
            if(i % 3 == 0) {
                // 请阿冲接牌
                linhuchong.add(c);
            }else if(i % 3 == 1){
                // 请阿鸠
                jiumozhi.add(c);
            }else if(i % 3 == 2){
                // 请盈盈接牌
                renyingying.add(c);
            }
        }

        // 12、拿到最后三张底牌(把最后三张牌截取成一个子集合)
        List<Card> lastThreeCards = allCards.subList(allCards.size() - 3 , allCards.size());

        // 13、给玩家的牌排序（从大到小 可以自己先试试怎么实现）
        sortCards(linhuchong);
        sortCards(jiumozhi);
        sortCards(renyingying);

        // 14、输出玩家的牌：
        System.out.println("啊冲：" + linhuchong);
        System.out.println("啊鸠：" + jiumozhi);
        System.out.println("盈盈：" + renyingying);
        System.out.println("三张底牌：" + lastThreeCards);
    }

    /**
       给牌排序
     * @param cards
     */
    private static void sortCards(List<Card> cards) {
        // cards = [J♥, A♦, 3♥, 🃏, 5♦, Q♥, 2♥
        Collections.sort(cards, new Comparator<Card>() {
            @Override
            public int compare(Card o1, Card o2) {
                // o1 = J♥
                // o2 = A♦
                // 知道牌的大小，才可以指定规则
                return o2.getIndex() - o1.getIndex();
            }
        });
    }
}

Map集合体系

Map集合的概述

Map集合概述和使用

• Map集合是一种双列集合，每个元素包含两个数据
• Map集合的每个元素的格式：key=value(键值对元素)。
• Map集合也被称为“键值对集合”。

Map集合整体格式：

• Collection集合的格式: [元素1,元素2,元素3…]
• Map集合的完整格式：{key1=value1 , key2=value2 , key3=value3 , …}

Map集合体系特点

说明

• 使用最多的Map集合是HashMap。
• 重点掌握HashMap , LinkedHashMap , TreeMap。其他的后续理解。

Map集合体系特点

• Map集合的特点都是由键决定的。
• Map集合的键是无序,不重复的，无索引的，值不做要求（可以重复）。
• Map集合后面重复的键对应的值会覆盖前面重复键的值。
• Map集合的键值对都可以为null。

Map集合实现类特点

• HashMap:元素按照键是无序，不重复，无索引，值不做要求。（与Map体系一致）
• LinkedHashMap:元素按照键是有序，不重复，无索引，值不做要求。
• TreeMap：元素按照建是排序，不重复，无索引的，值不做要求。

Map集合常用API

Map集合： Map是双列集合的祖宗接口，它的功能是全部双列集合都可以继承使用的。

Map常用API

方法名称	说明
V put(K key,V value)	添加元素
V remove(Object key)	根据键删除键值对元素
void clear()	移除所有的键值对元素
boolean containsKey(Object key)	判断集合是否包含指定的键
boolean containsValue(Object value)	判断集合是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中键值对的个数

Map集合的遍历方式一：键找值

Map集合的遍历方式有：3种。

• 方式一：键找值的方式遍历：先获取Map集合全部的键，再根据遍历键找值。
• 方式二：键值对的方式遍历，把“键值对“看成一个整体，难度较大。
• 方式三：JDK 1.8开始之后的新技术：Lambda表达式。

Map集合的遍历方式一：键找值

• 先获取Map集合的全部键的Set集合。
• 遍历键的Set集合，然后通过键提取对应值。

键找值涉及到的API:

方法名称	说明
Set< K> keySet()	获取所有键的集合
V get(Object key)	根据键获取值

public class MapDemo01 {
    public static void main(String[] args) {
        Map<String , Integer> maps = new HashMap<>();
        // 1.添加元素: 无序，不重复，无索引。
        maps.put("娃娃",30);
        maps.put("iphoneX",100);
        maps.put("huawei",1000);
        maps.put("生活用品",10);
        maps.put("手表",10);
        System.out.println(maps);
        // maps = {huawei=1000, 手表=10, 生活用品=10, iphoneX=100, 娃娃=30}

        // 1、键找值：第一步：先拿到集合的全部键。
        Set<String> keys = maps.keySet();
        // 2、第二步：遍历每个键，根据键提取值
        for (String key : keys) {
            int value = maps.get(key);
            System.out.println(key + "===>" + value);
        }
    }
}

Map集合的遍历方式二：键值对

Map集合的遍历方式二：键值对

• 先把Map集合转换成Set集合，Set集合中每个元素都是键值对实体类型了。
• 遍历Set集合，然后提取键以及提取值。

键值对涉及到的API

方法名称	说明
Set<Map.Entry<K,V>> entrySet()	获取所有键值对对象的集合
K getKey()	获得键
V getValue()	获取值

public class MapDemo02 {
    public static void main(String[] args) {
        Map<String , Integer> maps = new HashMap<>();
        // 1.添加元素: 无序，不重复，无索引。
        maps.put("娃娃",30);
        maps.put("iphoneX",100);
        maps.put("huawei",1000);
        maps.put("生活用品",10);
        maps.put("手表",10);
        System.out.println(maps);
        // maps = {huawei=1000, 手表=10, 生活用品=10, iphoneX=100, 娃娃=30}
        /**
            maps = {huawei=1000, 手表=10, 生活用品=10, iphoneX=100, 娃娃=30}
                
            使用foreach遍历map集合.发现Map集合的键值对元素直接是没有类型的。所以不可以直接foreach遍历集合。
                
            可以通过调用Map的方法 entrySet把Map集合转换成Set集合形式  maps.entrySet();
                
            Set<Map.Entry<String,Integer>> entries =  maps.entrySet();
             [(huawei=1000), (手表=10), (生活用品=10), (iphoneX=100), (娃娃=30)]
                              entry
                
            此时可以使用foreach遍历
       */
       // 1、把Map集合转换成Set集合
        Set<Map.Entry<String, Integer>> entries = maps.entrySet();
        // 2、开始遍历
        for(Map.Entry<String, Integer> entry : entries){
            String key = entry.getKey();
            int value = entry.getValue();
            System.out.println(key + "====>" + value);
        }
    }
}

Map集合的遍历方式三：lambda表达式

得益于JDK 8开始的新技术Lambda表达式，提供了一种更简单、更直接的遍历集合的方式。

Map结合Lambda遍历的API

方法名称	说明
default void forEach(BiConsumer<? super K, ? super V> action)	结合lambda遍历Map集合

public class MapDemo03 {
    public static void main(String[] args) {
        Map<String , Integer> maps = new HashMap<>();
        // 1.添加元素: 无序，不重复，无索引。
        maps.put("娃娃",30);
        maps.put("iphoneX",100);//  Map集合后面重复的键对应的元素会覆盖前面重复的整个元素！
        maps.put("huawei",1000);
        maps.put("生活用品",10);
        maps.put("手表",10);
        System.out.println(maps);

        //  maps = {huawei=1000, 手表=10, 生活用品=10, iphoneX=100, 娃娃=30}

//        maps.forEach(new BiConsumer<String, Integer>() {
//            @Override
//            public void accept(String key, Integer value) {
//                System.out.println(key + "--->" + value);
//            }
//        });

        maps.forEach((k, v) -> {
                System.out.println(k + "--->" + v);
        });
    }
}

Map集合的实现类HashMap

说明：

• 使用最多的Map集合是HashMap。
• 重点掌握HashMap , LinkedHashMap , TreeMap。其他的后续理解。

HashMap的特点

• HashMap是Map里面的一个实现类。特点都是由键决定的：无序、不重复、无索引
• 没有额外需要学习的特有方法，直接使用Map里面的方法就可以了。
• HashMap跟HashSet底层原理是一模一样的，都是哈希表结构，只是HashMap的每个元素包含两个值而已。

实际上：Set系列集合的底层就是Map实现的，只是Set集合中的元素只要键数据，不要值数据而
已

需求：创建一个HashMap集合，键是学生对象(Student)，值是籍贯(String)。存储三个键值对元素，并遍历。
思路：

1. 定义学生类
2. 创建HashMap集合对象
3. 创建学生对象
4. 把学生添加到集合
5. 遍历集合

public class MapTest1 {
    public static void main(String[] args) {
         // 1、把80个学生选择的数据拿进来。
        String[] selects = {"A" , "B", "C", "D"};
        StringBuilder sb = new StringBuilder();
        Random r = new Random();
        for (int i = 0; i < 80; i++) {
            sb.append(selects[r.nextInt(selects.length)]);
        }
        System.out.println(sb);

        // 2、定义一个Map集合记录最终统计的结果： A=30 B=20 C=20 D=10  键是景点 值是选择的数量
        Map<Character, Integer> infos = new HashMap<>(); //

        // 3、遍历80个学生选择的数据
        for (int i = 0; i < sb.length(); i++) {
            // 4、提取当前选择景点字符
            char ch = sb.charAt(i);
            // 5、判断Map集合中是否存在这个键
            if(infos.containsKey(ch)){
                 // 让其值 + 1
                infos.put(ch , infos.get(ch) + 1);
            }else {
                // 说明此景点是第一次被选
                infos.put(ch , 1);
            }
        }
        // 4、输出集合
        System.out.println(infos);

    }
}

Map集合的实现类LinkedHashMap

LinkedHashMap集合概述和特点

• 由键决定：有序、不重复、无索引。
• 这里的有序指的是保证存储和取出的元素顺序一致
• 原理：底层数据结构是依然哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序。（参考HashSet）

Map集合的实现类TreeMap

TreeMap集合概述和特点

• 由键决定特性：不重复、无索引、可排序
• 可排序：按照键数据的大小默认升序（有小到大）排序。只能对键排序。
• 注意：TreeMap集合是一定要排序的，可以默认排序，也可以将键按照指定的规则进行排序。
• TreeMap跟TreeSet一样底层原理是一样的。

TreeMap集合自定义排序规则有2种

• 类实现Comparable接口，重写比较规则。
• 集合自定义Comparator比较器对象，重写比较规则。

public class TreeMapDemo3 {
    public static void main(String[] args) {
        Map<Integer, String> maps1 = new TreeMap<>();
        maps1.put(13 , "王麻子");
        maps1.put(1 , "张三");
        maps1.put(3 , "县长");
        System.out.println(maps1);

        // TreeMap集合自带排序。  可排序 不重复（只要大小规则一样就认为重复）  无索引
        Map<Apple, String> maps2 = new TreeMap<>(new Comparator<Apple>() {
            @Override
            public int compare(Apple o1, Apple o2) {
                return Double.compare(o2.getPrice() , o1.getPrice()); // 按照价格降序排序！
            }
        });
        maps2.put(new Apple("红富士", "红色", 9.9, 500), "山东" );
        maps2.put(new Apple("青苹果", "绿色", 15.9, 300), "广州");
        maps2.put(new Apple("绿苹果", "青色", 29.9, 400), "江西");
        maps2.put(new Apple("黄苹果", "黄色", 9.8, 500), "湖北");

        System.out.println(maps2);
    }
}

补充知识：集合的嵌套

public class MapTest {
    public static void main(String[] args) {
        // 1、要求程序记录每个学生选择的情况。
        // 使用一个Map集合存储。
        Map<String, List<String>> data = new HashMap<>();

        // 2、把学生选择的数据存入进去。
        List<String> selects = new ArrayList<>();
        Collections.addAll(selects, "A", "C");
        data.put("罗勇", selects);

        List<String> selects1 = new ArrayList<>();
        Collections.addAll(selects1, "B", "C" , "D");
        data.put("胡涛", selects1);

        List<String> selects2 = new ArrayList<>();
        Collections.addAll(selects2 , "A",  "B", "C" , "D");
        data.put("刘军", selects2);

        System.out.println(data);

        // 3、统计每个景点选择的人数。
        Map<String, Integer> infos = new HashMap<>(); // {}

        // 4、提取所有人选择的景点的信息。
        Collection<List<String>> values = data.values();
        System.out.println(values);
        // values = [[A, B, C, D], [B, C, D], [A, C]]
        //             value

        for (List<String> value : values) {
            for (String s : value) {
                // 有没有包含这个景点
                if(infos.containsKey(s)){
                    infos.put(s, infos.get(s) + 1);
                }else {
                    infos.put(s , 1);
                }
            }
        }

        System.out.println(infos);
    }
}