集合进阶（Map集合）

Map实现类

同学们，我们已经学习了Map集合的常用方法，以及遍历方式。

下面我们要学习的是Map接口下面的是三个实现类HashMap、LinkedHashMap、TreeMap。实际上这三个实现类并没有什么特有方法需要我们学习，它们的方法就是前面学习Map的方法。

这里我们主要学习它们的底层原理。

2.1 HashMap

首先，我们学习HashMap集合的底层原理。前面我们学习过HashSet的底层原理，实际上HashMap底层原理和HashSet是一样的。为什么这么说呢？因为我们往HashSet集合中添加元素时，实际上是把元素添加到了HashMap集合中。

下面是Map集合的体系结构，HashMap集合的特点是由键决定的： 它的键是无序、不能重复，而且没有索引的 。再各种Map集合中也是用得最多的一种集合。

刚才我们说，HashSet底层就是HashMap，我们可以看源码验证这一点，如下图所示，我们可以看到，创建HashSet集合时，底层帮你创建了HashMap集合；往HashSet集合中添加添加元素时，底层却是调用了Map集合的put方法把元素作为了键来存储。所以实际上根本没有什么HashSet集合，把HashMap的集合的值忽略不看就是HashSet集合。

HashSet的原理我们之前已经学过了，所以HashMap是一样的，底层是哈希表结构。

复制代码

HashMap底层数据结构: 哈希表结构
    JDK8之前的哈希表 = 数组+链表
    JDK8之后的哈希表 = 数组+链表+红黑树
    哈希表是一种增删改查数据，性能相对都较好的数据结构
    
往HashMap集合中键值对数据时，底层步骤如下
    第1步：当你第一次往HashMap集合中存储键值对时，底层会创建一个长度为16的数组
    第2步：把键然后将键和值封装成一个对象，叫做Entry对象
    第3步：再根据Entry对象的键计算hashCode值（和值无关）
    第4步：利用hashCode值和数组的长度做一个类似求余数的算法，会得到一个索引位置
    第5步：判断这个索引的位置是否为null，如果为null,就直接将这个Entry对象存储到这个索引位置
           如果不为null，则还需要进行第6步的判断
    第6步：继续调用equals方法判断两个对象键是否相同
          如果equals返回false，则以链表的形式往下挂
          如果equals方法true,则认为键重复，此时新的键值对会替换就的键值对。
    
HashMap底层需要注意这几点：
    1.底层数组默认长度为16，如果数组中有超过12个位置已经存储了元素，则会对数组进行扩容2倍
      数组扩容的加载因子是0.75，意思是：16*0.75=12     
    
    2.数组的同一个索引位置有多个元素、并且在8个元素以内(包括8)，则以链表的形式存储
        JDK7版本：链表采用头插法（新元素往链表的头部添加）
        JDK8版本：链表采用尾插法（新元素我那个链表的尾部添加）
        
    3.数组的同一个索引位置有多个元素、并且超过了8个，则以红黑树形式存储

从HashMap底层存储键值对的过程中我们发现：决定键是否重复，依赖于两个方法，一个是hashCode方法、一个是equals方法。有两个键计算得到的hashCode值相同，并且两个键使用equals比较为true，就认为键重复。

所以，往Map集合中存储自定义对象作为键，为了保证键的唯一性，我们应该重写hashCode方法和equals方法。

比如有如下案例：往HashMap集合中存储Student对象作为键，学生的家庭住址当做值。要求，当学生对象的姓名和年龄相同时就认为键重复。

复制代码

public class Student implements Comparable<Student> {
    private String name;
    private int age;
    private double height;

    // this  o
    @Override
    public int compareTo(Student o) {
        return this.age - o.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 && Double.compare(student.height, height) == 0 && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, height);
    }

    public Student() {
    }

    public Student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    //...get,set方法自己补全....

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }
}

写一个测试类，在测试类中，创建HashMap集合，键是Student类型，值是Stirng类型

复制代码

/**
 * 目标：掌握Map集合下的实现类：HashMap集合的底层原理。
 */
public class MapTest1 {
    public static void main(String[] args) {
        // 创建Map集合
        Map<Student, String> map = new HashMap<>();
        map.put(new Student("蜘蛛精", 25, 168.5), "盘丝洞");
        map.put(new Student("蜘蛛精", 25, 168.5), "水帘洞");
        map.put(new Student("至尊宝", 23, 163.5), "水帘洞");
        map.put(new Student("牛魔王", 28, 183.5), "牛头山");
        System.out.println(map);
    }
}

上面存储的键，有两个蜘蛛精，但是打印出只会有最后一个。

复制代码

1、HashMap的特点和底层原理？
    由键决定：无序、不重复、无索引。HashMap底层是哈希表结构的。
    HashMap集合是一种增删改查数据，性能都较好的集合
    但是它是无序，不能重复，没有索引支持的（由键决定特点）
    HashMap的键依赖hashCode方法和equals方法保证键的唯一
    如果键存储的是自定义类型的对象，可以通过重写hashCode和equals方法，这样可以保证多个对象内容一样时，HashMap集合就能认为是重复的。

2、HashMap如何实现键的唯一性的？
    依赖hashCode方法和equals方法保证键的唯一。
    如果键要存储的是自定义对象，需要重写hashCode和equals方法。

2.2 LinkedHashMap

学习完HashMap集合的特点，以及底层原理。接下来我们学习一下LinkedHashMap集合。

LinkedHashMap集合的特点也是由键决定的：有序的、不重复、无索引。

复制代码

/**
 * 目标：掌握LinkedHashMap的底层原理。
 */
public class MapTest2 {
    public static void main(String[] args) {
        // Map<String, Integer> map = new HashMap<>();    //  按照键 无序，不重复，无索引。
        LinkedHashMap<String, Integer> map = new LinkedHashMap<>(); //  按照键 有序，不重复，无索引。
        map.put("手表", 100);
        map.put("手表", 220);
        map.put("手机", 2);
        map.put("Java", 2);
        map.put(null, null);
        System.out.println(map);
    }
}

运行上面代码发现，如果是LinedHashMap集合键存储和取出的顺序是一样的

如果是HashMap，键存储和取出的顺序是不一致的

LinkedHashMap的底层原理，和LinkedHashSet底层原理是一样的。底层多个一个双向链表来维护键的存储顺序。

取元素时，先取头节点元素，然后再依次取下一个几点，一直到尾结点。所以是有序的。

2.3 TreeMap

最后，我们再学习Map集合下面的另一个子类叫TreeMap。根据我们前面学习其他Map集合的经验，我们应该可以猜出TreeMap有什么特点。

TreeMap集合的特点也是由键决定的，默认按照键的升序排列，键不重复，也是无索引的。

TreeMap集合和TreeSet也是一样的，底层都是红黑树实现的。所以可以对键进行排序。

比如往TreeMap集合中存储Student对象作为键，排序方法有两种。直接看代码吧

**排序方式1：**写一个Student类，让Student类实现Comparable接口

复制代码

//第一步：先让Student类，实现Comparable接口
public class Student implements Comparable<Student>{
    private String name;
    private int age;
    private double height;
    //无参数构造方法
    public Student(){}
    //全参数构造方法
    public Student(String name, int age, double height){
        this.name=name;
        this.age=age;
        this.height=height;
    }
    //...get、set、toString()方法自己补上..
    
    //按照年龄进行比较，只需要在方法中让this.age和o.age相减就可以。
    /*
    原理：
    在往TreeSet集合中添加元素时，add方法底层会调用compareTo方法，根据该方法的
    结果是正数、负数、还是零，决定元素放在后面、前面还是不存。
    */
    @Override
    public int compareTo(Student o) {
        //this：表示将要添加进去的Student对象
        //o: 表示集合中已有的Student对象
        return this.age-o.age;
    }
}

**排序方式2：**在创建TreeMap集合时，直接传递Comparator比较器对象。

复制代码

/**
 * 目标：掌握TreeMap集合的使用。
 */
public class MapTest3 {
    public static void main(String[] args) {
        Map<Student, String> map = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Double.compare(o1.getHeight(), o2.getHeight());
            }
        });
        // Map<Student, String> map = new TreeMap<>(( o1,  o2) ->   Double.compare(o2.getHeight(), o1.getHeight()));
        map.put(new Student("蜘蛛精", 25, 168.5), "盘丝洞");
        map.put(new Student("蜘蛛精", 25, 168.5), "水帘洞");
        map.put(new Student("至尊宝", 23, 163.5), "水帘洞");
        map.put(new Student("牛魔王", 28, 183.5), "牛头山");
        System.out.println(map);
    }
}

这种方式都可以对TreeMap集合中的键排序。注意：只有HashMap的键才能排序，HashMap值不能排序。

复制代码

总结:
1、TreeMap集合的特点、原理是怎么样的？
    根据键可排序、不重复、无索引
    底层基于红黑树实现排序，增删改查性能较好

2、TreeMap集合对自定义类型的对象排序，有几种方式指定排序规则？
    2种。
    ①类实现Comparable接口，重写比较规则。
    ②集合自定义Comparator比较器对象，重写比较规则。

2.4 集合嵌套

各位同学，到现在为止我们把Map集合和Collection集合的都已经学习完了。但是在实际开发中可能还会存在一种特殊的用法。就是把一个集合当做元素，存储到另一个集合中去，我们把这种用法称之为集合嵌套。

下面通过一个案例给大家演示一下

案例分析

复制代码

1.从需求中我们可以看到，有三个省份，每一个省份有多个城市  Map<省份, List集合<市>>
    我们可以用一个Map集合的键表示省份名称，而值表示省份有哪些城市
2.而又因为一个省份有多个城市，同一个省份的多个城市可以再用一个List集合来存储。
    所以Map集合的键是String类型，而值是List集合类型
    HashMap<String, List<String>> map = new HashMap<>();

代码如下

复制代码

/**
 * 目标：理解集合的嵌套。
 * 江苏省 = "南京市","扬州市","苏州市","无锡市","常州市"
 * 湖北省 = "武汉市","孝感市","十堰市","宜昌市","鄂州市"
 * 河北省 = "石家庄市","唐山市", "邢台市", "保定市", "张家口市"
 */
public class MapDemo {
    public static void main(String[] args) {
        // 定义一个Map集合存储全部的省份信息，和其对应的城市信息。
        Map<String, List<String>> map = new HashMap<>();

        List<String> cities1 = new ArrayList<>();
        Collections.addAll(cities1, "南京市","扬州市","苏州市" ,"无锡市","常州市");
        map.put("江苏省", cities1);

        List<String> cities2 = new ArrayList<>();
        Collections.addAll(cities2, "武汉市","孝感市","十堰市","宜昌市","鄂州市");
        map.put("湖北省", cities2);

        List<String> cities3 = new ArrayList<>();
        Collections.addAll(cities3, "石家庄市","唐山市", "邢台市", "保定市", "张家口市");
        map.put("河北省", cities3);
        System.out.println(map);

        List<String> cities = map.get("湖北省");
        for (String city : cities) {
            System.out.println(city);
        }

        map.forEach((p, c) -> {
            System.out.println(p + "----->" + c);
        });
    }
}

三、JDK8新特性（Stream流）

各位同学，接下来我们学习一个全新的知识，叫做Stream流（也叫Stream API）。它是从JDK8以后才有的一个新特性，是专业用于对集合或者数组进行便捷操作的。有多方便呢？

什么是Stream？

也叫Stream流，是JDK8开始新增的一套API (java.util.stream.*)，可以用于操作集合或者数组的数据。

优势：

Stream流大量的结合了Lambda的语法风格来编程，提供了一种更加强大，更加简单的方式操作集合或者数组中的数据，代码更简洁，可读性更好。

我们用一个案例体验一下，然后再详细学习。

3.1 Stream流体验

案例需求：有一个List集合，元素有"张三丰","张无忌","周芷若","赵敏","张强"，找出姓张，且是3个字的名字，存入到一个新集合中去。

复制代码

public class StreamTest {
    public static void main(String[] args) {
        // 创建集合
        List<String> names = new ArrayList<>();
        // 批量存储数据
        Collections.addAll(names, "张三丰","张无忌","周芷若","赵敏","张强");
        // 打印集合
        System.out.println(names);
    }
}

用传统方式来做，代码是这样的

复制代码

// 找出姓张，且是3个字的名字，存入到一个新集合中去。
List<String> list = new ArrayList<>();
for (String name : names) {
    if(name.startsWith("张") && name.length() == 3){
        list.add(name);
    }
}
System.out.println(list);

用Stream流来做，代码是这样的（ps: 是不是想流水线一样，一句话就写完了）

复制代码

List<String> list2 = names.stream().filter(s -> s.startsWith("张") && s.length() == 3)
                .collect(Collectors.toList());
System.out.println(list2);

System.out.println("-----------------------------");

List<String> list3 = names.stream().filter(s -> s.startsWith("张")).filter(a -> a.length() == 3).collect(Collectors.toList());
System.out.println(list3);

先不用知道这里面每一句话是什么意思，具体每一句话的含义，待会再一步步学习。现在只是体验一下。

学习Stream流我们接下来，会按照下面的步骤来学习。

3.2 Stream流的创建

好，接下来我们正式来学习Stream流。先来学习如何创建Stream流、或者叫获取Stream流。

如何获取Stream流?

获取集合的Stream流

Collection提供的如下方法	说明
default Stream<E> stream()	获取当前集合对象的Stream流

获取数组的Stream流

Arrays类提供的如下方法	说明
public static <T> Stream<T> stream(T[] array)	获取当前数组的Stream流

Stream类提供的如下方法	说明
public static<T> Stream<T> of(T... values)	获取当前接收数据的Stream流

直接上代码演示

复制代码

/**
 * 目标：掌握Stream流的创建。
 */
public class StreamTest2 {
    public static void main(String[] args) {
        // 1. 如何获取list集合的Stream流
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "张三丰","张无忌","周芷若","赵敏","张强");
        Stream<String> stream = list.stream();

        // 2. 如何获取set集合的Stream流
        Set<String> set = new HashSet<>();
        Collections.addAll(set, "刘德华","张曼玉","蜘蛛精","马德","德玛西亚");
        Stream<String> stream1 = set.stream();

        // 3. 如何获取map集合的Stream流
        Map<String, Double> map = new HashMap<>();
        map.put("古力娜扎", 172.3);
        map.put("迪丽热巴", 168.3);
        map.put("马尔扎哈", 166.3);
        map.put("卡尔扎巴", 168.3);
        // 通过获取所有key 再获取stream流
        Set<String> keys = map.keySet();
        Stream<String> ks = keys.stream();
        
        // 通过获取所有value 再获取stream流
        Collection<Double> values = map.values();
        Stream<Double> vs = values.stream();

        // 通过获取entry对象  再获取stream流
        Set<Map.Entry<String, Double>> entries = map.entrySet();
        Stream<Map.Entry<String, Double>> kvs = entries.stream();
        kvs.filter(s -> s.getKey().contains("扎")).collect(Collectors.toList())
                .forEach(s -> System.out.println(s.getKey() + " --> " + s.getValue()));

        // 4. 如何获取数组的Stream流
        String[] names = {"张翠山", "东方不败", "唐大山", "独孤求败"};
        Stream<String> s1 = Arrays.stream(names);
        Stream<String> s2 = Stream.of(names);
    }
}

3.3 Stream流中间方法

在上一节，我们学习了创建Stream流的方法。接下来我们再来学习，Stream流中间操作的方法。

中间方法指的是：调用完方法之后其结果是一个新的Stream流，于是可以继续调用方法，这样一来就可以支持链式编程（或者叫流式编程）。

话不多说，直接上代码演示

复制代码

/**
 * 目标：掌握Stream流提供的常见中间方法。
 */
public class StreamTest3 {
    public static void main(String[] args) {
        // 创建list集合
        List<Double> scores = new ArrayList<>();
        Collections.addAll(scores, 88.5, 100.0, 60.0, 99.0, 9.5, 99.6, 25.0);
        System.out.println(scores);
        // 需求1：找出成绩大于等于60分的数据，并升序后，再输出。
        scores.stream().filter(s -> s >= 60).sorted().forEach(s -> System.out.println(s));

        System.out.println("------------------------------------------------");

        List<Student> students = new ArrayList<>();
        Student s1 = new Student("蜘蛛精", 26, 172.5);
        Student s2 = new Student("蜘蛛精", 26, 172.5);
        Student s3 = new Student("紫霞", 23, 167.6);
        Student s4 = new Student("白晶晶", 25, 169.0);
        Student s5 = new Student("牛魔王", 35, 183.3);
        Student s6 = new Student("牛夫人", 34, 168.5);
        Collections.addAll(students, s1, s2, s3, s4, s5, s6);
        // 需求2：找出年龄大于等于23,且年龄小于等于30岁的学生，并按照年龄降序输出.
        students.stream().filter(s -> s.getAge() >= 23 && s.getAge() <= 30)
                .sorted(((o1, o2) -> o2.getAge() - o1.getAge()))
                .forEach(s -> System.out.println(s));

        System.out.println("------------------------------------------------");

        // 需求3：取出身高最高的前3名学生，并输出。
        students.stream().sorted(((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight())))
                .limit(3)
                .forEach(s -> System.out.println(s));

        System.out.println("------------------------------------------------");

        // 需求4：取出身高倒数的2名学生，并输出。   s1 s2 s3 s4 s5 s6
        students.stream().sorted(((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight())))
                .skip(students.size() - 2)
                .forEach(s -> System.out.println(s));

        System.out.println("------------------------------------------------");

        // 需求5：找出身高超过168的学生叫什么名字，要求去除重复的名字，再输出。
        students.stream().filter(s -> s.getHeight() > 168)
                .map(Student::getName)
                .distinct()
                .forEach(System.out::println);

        System.out.println("------------------------------------------------");

        // distinct去重复，自定义类型的对象（希望内容一样就认为重复，重写hashCode,equals）
        students.stream().filter(s -> s.getHeight() > 168)
                .distinct()
                .forEach(System.out::println);

        System.out.println("------------------------------------------------");

        // 合并a和b两个流为一体
        Stream<String> st1 = Stream.of("张三", "李四");
        Stream<String> st2 = Stream.of("张三2", "李四2", "王五");
        Stream<String> allSt = Stream.concat(st1, st2);
        allSt.forEach(System.out::println);
    }
}

3.4 Stream流终结方法

最后，我们再学习Stream流的终结方法。这些方法的特点是，调用完方法之后，其结果就不再是Stream流了，所以不支持链式编程。

我列举了下面的几个终结方法，接下来用几个案例来一个一个给同学们演示。

收集Stream流：就是把Stream流操作后的结果转回到集合或者数组中去返回。

Stream流 ：方便操作集合/数组的手段；集合/数组：才是开发中的目的。

话不多说，直接上代码

复制代码

/**
 * 目标：Stream流的终结方法
 */
public class StreamTest4 {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        Student s1 = new Student("蜘蛛精", 26, 172.5);
        Student s2 = new Student("蜘蛛精", 26, 172.5);
        Student s3 = new Student("紫霞", 23, 167.6);
        Student s4 = new Student("白晶晶", 25, 169.0);
        Student s5 = new Student("牛魔王", 35, 183.3);
        Student s6 = new Student("牛夫人", 34, 168.5);
        Collections.addAll(students, s1, s2, s3, s4, s5, s6);
        // 需求1：请计算出身高超过168的学生有几人。
        long size = students.stream().filter(s -> s.getHeight() > 168).count();
        System.out.println(size);

        // 需求2：请找出身高最高的学生对象，并输出。
        Student s = students.stream().max((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
        System.out.println(s);

        // 需求3：请找出身高最矮的学生对象，并输出。
        Student ss = students.stream().min((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
        System.out.println(ss);

        // 需求4：请找出身高超过170的学生对象，并放到一个新集合中去返回。
        // 流只能收集一次。
        List<Student> students1 = students.stream().filter(a -> a.getHeight() > 170).collect(Collectors.toList());
        System.out.println(students1);

        Set<Student> students2 = students.stream().filter(a -> a.getHeight() > 170).collect(Collectors.toSet());
        System.out.println(students2);

        // 需求5：请找出身高超过170的学生对象，并把学生对象的名字和身高，存入到一个Map集合返回。
        Map<String, Double> map =
                students.stream().filter(a -> a.getHeight() > 170)
                        .distinct().collect(Collectors.toMap(a -> a.getName(), a -> a.getHeight()));
        System.out.println(map);

        // Object[] arr = students.stream().filter(a -> a.getHeight() > 170).toArray();
        Student[] arr = students.stream().filter(a -> a.getHeight() > 170).toArray(len -> new Student[len]);
        System.out.println(Arrays.toString(arr));
    }
}

到这里，关于Stream流的操常见操作我们就已经学习完了。当然Stream流还有一些其他的方法，同学们遇到了也可以自己再研究一下。