20天深度复习JavaSE的详细笔记(十三)——集合（Set、Collections、Map、集合嵌套）

忘是亡心i 2023-10-02 21:03 8阅读 0赞

#### 文章目录 ####

*  Demo13-集合（Set、Collections、Map、集合嵌套）
 *   *  1.Set集合
     *   *  1.1Set系列集合特点:
         *  1.2HashSet元素无序的底层原理
         *  1.3HashSet元素去重复的底层原理
         *  1.4LinkedHashSet
         *  1.5TreeSet
         *  1.6Collection体系使用场景
     *  2.可变参数
     *  3.Collections工具类
     *  4.Map集合
     *   *  4.1Map集合概述
         *  4.2Map集合体系
         *  4.3Map集合常用API
         *  4.4Map集合的遍历方式
         *   *  4.4.1遍历方式一:键找值
             *  4.4.2遍历方式二:键值对
             *  4.4.2遍历方式三:Lambda表达式
         *  4.5集合案例
         *  4.6HashMap集合
         *  4.7LinkedHashMap集合
         *  4.8TreeMap集合
         *  4.9集合嵌套案例

## Demo13-集合（Set、Collections、Map、集合嵌套） ##

### 1.Set集合 ###

#### 1.1Set系列集合特点: ####

*  无序:存取顺序不一致
 *  不重复:可以去除重复
 *  无索引:底层实现是有索引的,但是因为Set集合的特殊性,没有对外公开索引,所以就没有带索引的方法,所以不能使用普通for循环遍历,也不能通过索引来获取元素

Set:

*  HashSet:无序,不重复无索引
    
     *  LinkedHashSet:有序,不重复,无索引(有序指的是保证存储和取出的元素顺序一致)
 *  TreeSet:排序,不重复,无索引

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

#### 1.2HashSet元素无序的底层原理 ####

*  HashSet集合底层采取哈希表存储数据,哈希表是一种对于增删改查数据性能都较好的结构
 *  哈希表的组成:
    
     *  JDK8之前,底层使用数组+链表组成
     *  JDK8之后,底层采用数组+链表+红黑树组成
 *  在了解哈希表之前需要先理解哈希值的概念
    
     *  哈希值是JDK根据对象的地址,按照某种规则算出来的**int类型的数值**
     *  通过Object类的API返回对象的哈希值:public int hashCode();
     *  对象的哈希值特点:
        
         *  同一个对象多次调用hashCode()方法返回的哈希值是相同的
         *  默认情况下,不同对象的哈希值是不同的

1.HashSet1.7版本原理解析:**数组+链表**(结合哈希算法)

*  创建一个默认长度为16的数组,数组名为table
 *  根据元素的哈希值跟数组的长度求余计算出应存入的位置(哈希算法)
    
     *  判断当前位置是否为null,如果是null直接存入
     *  如果位置不为null,表示有元素,则调用equals方法比较,如果一样,则不存,如果不一样,则存入数组
        
         *  JDK7新元素占老元素位置,指向老元素
         *  JDK8新元素挂老元素下面
 *  当数组存满到16\*0.75=12时,就自动扩容,每次扩容原先的两倍

**因为是数组+链表的组成方式,所以哈希表是一种对于增删改查数据性能都较好的结构**

2.JDK1.8版本开始HashSet原理解析:**数组,链表,红黑树**(结合哈希算法)

*  当挂在元素下面的数据过多时,查询性能降低,从JDK8开始后,当链表长度超过8时,自动转换为红黑树

#### 1.3HashSet元素去重复的底层原理 ####

Set集合去重复规则:**先判断哈希值,再判断equals**

如果希望Set集合认为两个内容一样的对象是重复的,必须重写对象的HashCode()和equals()方法:

*  重写HashCode方法:
    
     *  因为new两个内容一样的对象,这两个对象地址不同,那得到的哈希值大概率不同,最后就会向HashSet存内容一样的对象
     *  为了避免这种情况我们就要重写HashCode使内容一样的对象哈希值一样
 *  重写equals方法:
    
     *  因为Object类的equals方法是比较地址是否相同
     *  我们的需求是比较对象内容是否相同,所以重写equals方法

public class SetDemo3 {
        
        public static void main(String[] args) {
        
            Set<Student> sets = new HashSet<>();
            Student s1 = new Student("无恙",15);
            Student s2 = new Student("无恙",15);
            System.out.println(s1.hashCode());
            System.out.println(s2.hashCode());
            sets.add(s1);
            sets.add(s2);
            System.out.println(sets);
        }
    }
    
    public class Student {
        
        private String name;
        private int age;
        public Student(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
        @Override
        public boolean equals(Object o) {
        
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Student student = (Student) o;
            return age == student.age && Objects.equals(name, student.name);
        }
        @Override
        public int hashCode() {
        
            return Objects.hash(name, age);
        }
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

关于重写后的hashCode方法:

不用管Objects.hash(name, age)内部是怎么实现的,只需要知道,两个内容相同的对象给hash方法传入的参数一定是一模一样的,那么无所谓hash方法内部怎么实现,反正最后结果一定一样

#### 1.4LinkedHashSet ####

存储和取出的元素顺序一致的原理:底层数据结构依然是哈希表,只是每个元素又额外多了一个双链表机制记录存储的顺序

#### 1.5TreeSet ####

解释一下可排序:

*  按照元素的大小默认升序(由小到大)排序
 *  TreeSet集合底层是基于红黑树的数据结构实现排序的,增删改查性能都较好
 *  **TreeSet集合是一定要排序的**,可以将元素按照指定的规则进行排序

TreeSet集合默认的规则:

*  对于数值类型:Integer,Double,官方默认按照大小进行升序排序
 *  对于字符串类型:默认按照首字符的编号升序排序("a"是97,"A"是65,中文字符好像都是好几万)
    
        Set<String> sets1 = new TreeSet<>();
        sets1.add("angela");
        sets1.add("情话");
        sets1.add("Java");
        System.out.println(sets1);//输出[Java, angela, 情话]
 *  对于自定义类型如Student对象,TreeSet无法直接排序(运行会报ClassCastException异常)
    
     *  想要使用TreeSet存储自定义类型,需要制定排序规则
     *  为什么1.基本数据类型的包装类如Integer,Double2.引用类型String有默认排序方法呢
        
         *  因为这些类已经继承了Comparable接口并重写了排序方法(后面学到的Collections类的public static void sort(List list)方法等等其他有关排序的方法也是同理)

TreeSet集合存储对象时有2种方式可以自定义比较规则:

*  让自定义的类(如学生类)实现Comparable接口并重写里面的compareTo方法来定制比较规则
 *  TreeSet集合有参构造器可以设置Comparator接口对应的比较器对象,来定制比较规则(可以这样理解:因为TreeSet集合在加入元素时必须要排序,所以有参构造器支持比较器)
 *  **如果TreeSet集合存储的对象有实现比较规则,集合也自带比较器,根据就近原则默认使用集合自带的比较器排序**

public class SetDemo5 {
        
        public static void main(String[] args) {
        
            // 方式二：集合自带比较器对象进行规则定制
    //        Set<Apple> apples = new TreeSet<>(new Comparator<Apple>() {
        
    //            @Override
    //            public int compare(Apple o1, Apple o2) {
        
    //                return o2.getWeight() - o1.getWeight() >= 0 ? 1 : -1;//保留重量重复的元素(降序排序)
    //            }
    //        });
            
            //方式二的Lambda表达式写法
            Set<Apple> apples = new TreeSet<>((o1, o2) -> o2.getWeight() - o1.getWeight() >= 0 ? 1 : -1);
            apples.add(new Apple("红富士", 500));
            apples.add(new Apple("绿苹果", 400));
            apples.add(new Apple("黄苹果", 500));
            System.out.println(apples);
        }
    }
    
    public class Apple implements Comparable<Apple>{
        
        private String name;
        private int weight;
        public Apple(String name, int weight) {
        
            this.name = name;
            this.weight = weight;
        }
        public String getName() {
        
            return name;
        }
        public void setName(String name) {
        
            this.name = name;
        }
        public int getWeight() {
        
            return weight;
        }
        public void setWeight(int weight) {
        
            this.weight = weight;
        }
        @Override
        public String toString() {
        
            return "Apple{" +
                    "name='" + name + '\'' +
                    ", weight=" + weight +
                    '}';
        }
        //方式一：类自定义比较规则
        @Override
        public int compareTo(Apple o) {
        
    //        return this.weight - o.weight ; // 去重重量重复的元素
             return this.weight - o.weight >= 0 ? 1 : -1;//保留重量重复的元素(升序排序)
        }
    }

#### 1.6Collection体系使用场景 ####

*  如果希望元素可以重复,又有索引,索引查询要快
    
     *  用ArrayList集合,基于数组的
 *  如果希望元素可以重复,又有索引,增删首尾操作快
    
     *  用LinkedList集合,基于链表的
 *  如果希望增删改查都快,但是元素不重复,无序,无索引
    
     *  用HashSet集合,基于哈希表的
 *  如果希望增删改查都快,但是元素不重复,有序,无索引
    
     *  用LinkedHashSet集合,基于哈希表和双链表
 *  如果要对对象进行排序
    
     *  用TreeSet集合,基于红黑树
     *  后续也可以用List集合实现排序

### 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、可以传输一个数组
        }
        public static void sum(int...nums){
        
            // 注意：可变参数在方法内部其实就是一个数组
            System.out.println("元素个数：" + nums.length);
            System.out.println("元素内容：" + Arrays.toString(nums));
        }
    }

### 3.Collections工具类 ###

在util包下,是用来操作集合的工具类:

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public static boolean addAll(Collection&lt;? super T&gt; c, T…elements)</td> 
   <td>给集合对象批量添加元素</td> 
  </tr> 
  <tr> 
   <td>public static void shuffle(list&lt;?&gt; list)</td> 
   <td>打乱<strong>List集合</strong>元素的顺序</td> 
  </tr> 
 </tbody> 
</table>

1.关于addAll(Collection<? super T> c, T…elements):

*  第一个参数Collection<? super T> c中的<? super T>表示T的类型是?本身或其孩子比如我给第一个参数传List,那么T就可以是Animal或Cat或Dog等等等等
 *  第二个是可变参数,其参数类型是T,所以可变参数的类型就可以是Animal或Cat或Dog等等等等
 *  最后结果是List类型的变量指向的集合对象中可以存放Dog对象
    
     *  但是1.List类型的变量存储的并不是指向Dog对象的地址(存储的是List实现类的实例对象的地址)
     *  2.即使List类型的变量存储的是指向Dog对象的地址,但是Dog类并没有继承List
     *  所以严格意义上来说这并不是多态*只是呢,我个人认为这个想法来自于多态的理念*
        
         *  回顾一下什么是多态:Animal a = new Dog();
         *  1.Animal类型的变量存储的是指向Dog对象的地址
         *  2.Dog类必须继承Animal类

2.关于shuffle:

*  看方法源码会发现底层原理就是遍历数组,每次遍历随机出来一个索引,将此时遍历到的某一元素与随机出来的索引位置的元素交换位置
 *  为什么不能对Set集合使用只能对List集合使用呢,因为List集合底层是数组,而Set集合底层是根据一些算法得到将元素存放到数组的特定位置(后面还有两个排序的API,同理)

public class CollectionsDemo01 {
        
        public static void main(String[] args) {
        
            List<String> names = new ArrayList<>();
            Collections.addAll(names, "gg");
            Collections.addAll(names, new String[] {
        "楚留香","胡铁花"});
            System.out.println(names);//[gg, 楚留香, 胡铁花]
            Collections.shuffle(names);
            System.out.println(names);//[楚留香, gg, 胡铁花](每次运行程序可能结果都不一样)
        }
    }

--------------------

**Collections相关排序API只能适用于对List集合的排序**:

排序方式一(不可以直接对自定义类型的List集合排序,否则编译阶段报错,除非自定义类型实现了比较规则Comparable接口):

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public static void sort(List list)</td> 
   <td>将集合中元素按照默认规则排序</td> 
  </tr> 
 </tbody> 
</table>

排序方式二:

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public static void sort(List list, Comparator&lt;? super T&gt; c)</td> 
   <td>将集合中元素按照指定规则排序</td> 
  </tr> 
 </tbody> 
</table>

public class CollectionsDemo02 {
        
        public static void main(String[] args) {
        
            List<Apple> apples = new ArrayList<>(); // 可以重复！
            apples.add(new Apple("红富士", 500));
            apples.add(new Apple("绿苹果", 400));
            apples.add(new Apple("黄苹果", 500));
             //方式二：sort方法自带比较器对象
    //        Collections.sort(apples, new Comparator<Apple>() {
        
    //            @Override
    //            public int compare(Apple o1, Apple o2) {
        
    //                return Double.compare(o2.getWeight() , o1.getWeight());
    //            }
    //        });
    
            //方式二的Lambda表达式写法
            //注意:定制排序规则时不用像TreeSet那样强制保留大小相同的元素,因为List集存储相同大小的元素时会自动保留
            Collections.sort(apples, (o1, o2) -> o2.getWeight() - o1.getWeight());
            System.out.println(apples);
        }
    }
    
    public class Apple implements Comparable<Apple>{
        
        private String name;
        private int weight;
        public Apple(String name, int weight) {
        
            this.name = name;
            this.weight = weight;
        }
        public int getWeight() {
        
            return weight;
        }
        @Override
        public String toString() {
        
            return "Apple{" +
                    "name='" + name + '\'' +
                    ", weight=" + weight +
                    '}';
        }
        //方式一：类自定义比较规则
        @Override
        public int compareTo(Apple o) {
        
            // 按照重量进行比较的
            return this.weight - o.weight ;//TreeSet:return this.weight - o.weight >= 0 ? 1 : -1;
            //这里不用像TreeSet那样强制保留大小相同的元素,因为List集存储相同大小的元素时会自动保留
        }
    }

注意事项:

*  大体和制定Treeset比较规则一样,区别是:
    
     *  TreeSet比较到大小相同元素时会扔掉一个,想保留的话需要用return this.weight - o.weight >= 0 ? 1 : -1;
     *  List比较到大小相同元素时会自动保留
 *  **如果List集合存储的对象有实现比较规则,调用Collections的sort方法时也指定了排序规则,根据就近原则默认使用调sort方法时指定的排序规则**
 *  List和TreeSet排序区别:
    
     *  TreeSet是在加入元素时就进行排序了,而List是需要调用Collections的sort方法进行排序
     *  如果不保留大小相同的元素,就用TreeSet
     *  如果保留大小相同的元素,两者都可以用

### 4.Map集合 ###

#### 4.1Map集合概述 ####

*  Map集合是一种双列集合,每个元素包含两个数据
 *  Map集合的每个元素的格式:key=value(键值对元素),故Map集合也被称为"键值对集合"
    
     *  Map集合的键无序,不重复(后面重复的键对应的**元素会覆盖前面重复的整个元素**)
     *  Map集合的值不做要求,可以重复
     *  **Map集合的键值对都可以为null**
        
            public class MapDemo1 {
                    
                public static void main(String[] args) {
                    
                    Map<String, Integer> maps = new LinkedHashMap<>();
                    maps.put(null, null);
                    System.out.println(maps);//输出{null=null}
                }
            }
 *  Collection集合和Map集合格式:
    
     *  Collection集合的格式:\[元素1,元素2,元素3,…\]
     *  Map集合的格式:\{key1=value,key2=value,key3=value,…\}

#### 4.2Map集合体系 ####

*  Map集合体系(元素按照是无序,键不重复,无索引,值不做要求)
    
     *  HashMap(元素按照是无序,键不重复,无索引,值不做要求,**与Map体系一致**)
        
         *  LinkedHashMap(元素按照键**有序**,键不重复,无索引,值不做要求)
     *  HashTable(不关心,只关心其子类Properties)
        
         *  Properties
     *  AbstractMap(不关心,只关心其实现类TreeMap)
        
         *  TreeMap(元素按照键**排序**,键不重复,无索引,值不做要求)

#### 4.3Map集合常用API ####

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>V put(K key, V value)</td> 
   <td>添加元素</td> 
  </tr> 
  <tr> 
   <td>V remove(K key, V value)</td> 
   <td>根据键删除键值对元素,返回删除的键值对的值</td> 
  </tr> 
  <tr> 
   <td>void clear()</td> 
   <td>移除所有的键值对元素</td> 
  </tr> 
  <tr> 
   <td>boolean containsKey(Object key)</td> 
   <td>判断集合是否包含指定的键</td> 
  </tr> 
  <tr> 
   <td>boolean containsValue(Object value)</td> 
   <td>判断集合是否包含指定的值</td> 
  </tr> 
  <tr> 
   <td>boolean isEmpty()</td> 
   <td>判断集合是否为空</td> 
  </tr> 
  <tr> 
   <td>int size()</td> 
   <td>集合的长度,也就是集合中键值对的个数</td> 
  </tr> 
  <tr> 
   <td>Set keySet()</td> 
   <td>获取全部建的集合</td> 
  </tr> 
  <tr> 
   <td>Collection values()</td> 
   <td>获取全部值的集合</td> 
  </tr> 
  <tr> 
   <td>V get(Object key)</td> 
   <td>根据键获取对应值</td> 
  </tr> 
  <tr> 
   <td>void putAll(Map&lt;? extends K, ? extends V&gt; m);</td> 
   <td>合并其他Map集合</td> 
  </tr> 
 </tbody> 
</table>

关于Set keySet():

*  Map的键是无序不重复的,和Set一样,所以可以用Set集合接Map的键
 *  这个方法内部实际上就是new了一个HashSet来存放集合经过一些操作后返回该HashSet集合对象
 *  因为HashMap在存放数据时键的底层和HashSet实现原理一样,所以**keySet()方法得到的键的Set集合中元素顺序和HashMap中键顺序一致**

关于Collection values():

*  为什么这里用Collection接Map的值呢:因为值可能重复,如果还用Set的话会丢失数据
 *  values方法内部可能new了List集合的子类,然后将HashMap中元素的值依次存放到数组中,所以**values方法得到的值的Collection集合中元素顺序和HashMap中值顺序一致**

public class MapDemo {
        
        public static void main(String[] args) {
        
            // 1.添加元素: 无序，不重复，无索引。
            Map<String , Integer> maps = new HashMap<>();
            maps.put("iphoneX",10);
            maps.put("娃娃",20);
            maps.put("iphoneX",100);//Map集合后面重复的键对应的元素会覆盖前面重复的整个元素！
            maps.put("huawei",200);
            maps.put("生活用品",50);
            System.out.println(maps);//{huawei=200, 生活用品=50, iphoneX=100, 娃娃=20}
            // 2.清空集合
    //        maps.clear();
            // 3.判断集合是否为空
            System.out.println(maps.isEmpty());//false
            // 4.根据键获取对应值
            Integer key = maps.get("huawei");
            System.out.println(key);//200
            System.out.println(maps.get("生活用品"));//50
            System.out.println(maps.get("生活用品2"));//null
            // 5.根据键删除整个元素
            System.out.println(maps.remove("iphoneX"));//100
            System.out.println(maps);//{huawei=200, 生活用品=50, 娃娃=20}
            // 6.判断是否包含某个键
            System.out.println(maps.containsKey("娃娃"));// true
            System.out.println(maps.containsKey("娃娃2"));// false
            // 7.判断是否包含某个值
            System.out.println(maps.containsValue(200));//true
            // 8.获取全部键的集合
            Set<String> keys = maps.keySet();
            System.out.println(keys);//[huawei, 生活用品, 娃娃],注意顺序:和HashMap中元素顺序一致
            // 9.获取全部值的集合
            Collection<Integer> values = maps.values();
            System.out.println(values);//[200, 50, 20],注意顺序:和HashMap中元素顺序一致
            // 10.集合的大小
            System.out.println(maps.size());//3
            // 11.合并其他Map集合
            Map<String , Integer> map1 = new HashMap<>();
            map1.put("java1", 1);
            map1.put("java2", 100);
            Map<String , Integer> map2 = new HashMap<>();
            map2.put("java2", 1);
            map2.put("java3", 100);
            map1.putAll(map2); // 把集合map2的元素拷贝一份到map1中去
            System.out.println(map1);//{java3=100, java2=1, java1=1}
            System.out.println(map2);//{java3=100, java2=1}
        }
    }

#### 4.4Map集合的遍历方式 ####

##### 4.4.1遍历方式一:键找值 #####

*  先获取Map集合的全部建的Set集合
 *  遍历建的Set集合,然后通过键提取对应值

键找值涉及到的API:

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Set keySet()</td> 
   <td>获取全部建的集合</td> 
  </tr> 
  <tr> 
   <td>V get(Object key)</td> 
   <td>根据键获取对应值</td> 
  </tr> 
 </tbody> 
</table>

public class MapDemo01 {
        
        public static void main(String[] args) {
        
            Map<String , Integer> maps = new HashMap<>();
            maps.put("娃娃",30);
            maps.put("iphoneX",100);
            System.out.println(maps);
            Set<String> keys = maps.keySet();
            for (String key : keys) {
        
                int value = maps.get(key);//自动拆箱
                System.out.println(key + "===>" + value);
            }
        }
    }

##### 4.4.2遍历方式二:键值对 #####

*  先把Map集合转换成Set集合,Set集合中每个元素都是键值对实体类型了(HashMap是一个键值对的集合,里面的键和值作为整体没有所谓的类型,所以我们不能通过简单的循环来遍历HashMap)
 *  遍历Set集合,然后提取键以及提取值

键值对涉及到的API:

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Set&lt;Map.Entry&lt;K, V&gt;&gt; entrySet()</td> 
   <td>获取所有键值对对象的集合</td> 
  </tr> 
  <tr> 
   <td>K getKey()</td> 
   <td>获取某一个键值对元素的键</td> 
  </tr> 
  <tr> 
   <td>V get(Object key)</td> 
   <td>根据键获取对应值</td> 
  </tr> 
 </tbody> 
</table>

public class MapDemo02 {
        
        public static void main(String[] args) {
        
            Map<String , Integer> maps = new HashMap<>();
            maps.put("娃娃",30);
            maps.put("iphoneX",100);
            System.out.println(maps);
            Set<Map.Entry<String, Integer>> entries = maps.entrySet();//这一步的底层原理以后再研究
            for(Map.Entry<String, Integer> entry : entries){
        
                String key = entry.getKey();
                int value = entry.getValue();
                System.out.println(key + "====>" + value);
            }
        }
    }

##### 4.4.2遍历方式三:Lambda表达式 #####

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

Map结合Lambda遍历的API

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>default void forEach(BiConsumer&lt;? super K, ? super V&gt; action)</td> 
   <td>结合Lambda遍历Map集合</td> 
  </tr> 
 </tbody> 
</table>

public class MapDemo03 {
        
        public static void main(String[] args) {
        
            Map<String , Integer> maps = new HashMap<>();
            maps.put("娃娃",30);
            maps.put("iphoneX",100);
            System.out.println(maps);
            //方式三
            maps.forEach(new BiConsumer<String, Integer>() {
        
                @Override
                public void accept(String key, Integer value) {
        
                    System.out.println(key + "--->" + value);
                }
            });
            //方式三的Lambda表达式简化
            maps.forEach((k, v) -> {
        
                    System.out.println(k + "--->" + v);
            });
        }
    }

**点进去forEach看源码会发现这其实就是一个换壳简化,实际上还是用了方式二的这种方法**

default void forEach(BiConsumer<? super K, ? super V> action) {
        
        Objects.requireNonNull(action);
        for (Map.Entry<K, V> entry : entrySet()) {
        
            K k;
            V v;
            try {
        
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
        
                throw new ConcurrentModificationException(ise);
            }
            action.accept(k, v);
        }
    }

#### 4.5集合案例 ####

> 某个班80名学生,现在需要组成秋游活动,班长提供了四个景点依次是(A,B,C,D),每个学生只能选择一个景点,请统计最终哪个景点想去的人数最多

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

#### 4.6HashMap集合 ####

*  HashMap是Map里面的一个实现类,特点都是由键决定的:无序,不重复,无索引
    
     *  依赖HashCode方法和equals方法保证键的唯一
     *  如果键要存储的是自定义对象,需要重写hashCoe和equals方法
 *  没有额外需要学习的方法,直接使用Map里面的方法就可以了
 *  HashMap跟HashSet底层原理一模一样,都是哈希表结构,**增删改查性能都比较好**,只是HashMap的每个元素包含两个值而已
 *  **实际上,Set系列的集合的底层就是Map实现的,只是Set集合中的元素只要键数据,不要值数据而已,所以Map底层直接去看1.2和1.3就可以了,学到这里了顺便纠正一下,1.2和1.3讲解的底层严格意义上来讲不应该算是Set的底层而应该算是Map的底层,然后Set进行调用,说白了Set的底层实现是依据Map**例如:
    
        public HashSet() {
              
            map = new HashMap<>();
        }

#### 4.7LinkedHashMap集合 ####

*  LinkedHashSet底层就是依据LinkedHashMap做的
 *  有序,不重复,无索引(这里的有序指的是保证存储和取出的元素顺序一致)
 *  原理:底层数据结构依然是哈希表,只是每个键值对元素又额外多了一个双链表的机制记录存储的顺序

#### 4.8TreeMap集合 ####

*  TreeSet底层就是依据TreeMap做的
 *  不重复,无索引,可排序
    
     *  排序是按照键数据的大小默认升序(**只能对键排序,且如果是自定义的引用类型那么必须自定义排序规则**)
     *  自定义排序规则有2种:
        
         *  类实现Comparable接口,重写比较规则
         *  集合自定义Comparator比较器对象,重写比较规则

#### 4.9集合嵌套案例 ####

> 某个班80名学生,现在需要组成秋游活动,班长提供了四个景点依次是(A,B,C,D),每个学生可以选择景点,请统计最终哪个景点想去的人数最多

public class MapTest4 {
        
        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);//{刘军=[A, B, C, D], 胡涛=[B, C, D], 罗勇=[A, C]}
    
            // 3、统计每个景点选择的人数。
            Map<String, Integer> infos = new HashMap<>(); // {}
    
            // 4、提取所有人选择的景点的信息。
            Collection<List<String>> values = data.values();
            System.out.println(values);//[[A, B, C, D], [B, C, D], [A, C]]
    
            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);//{A=2, B=2, C=3, D=2}
        }
    }