### java8之collector详解，以及结合toMap，sorted，groupingBy使用例子

逃离我推掉我的手 2021-11-11 09:18 683阅读 0赞

最近接触到java8的collector功能，网上查了下资料学习，这里记录一下。

`collect`方法，它是一个能够把stream管道中的结果集装进一个`List`集合的终极操作。 `collect`是一个把stream规约成一个value的规约操作，这里的value可以是一个Collection、Map或者一个value对象。在下面这几种情况下，可以使用`collect`操作。

1.  **把stream规约到一个单独的值** stream的执行结果可以规约成一个单独的值，这个单独的值可以是`Collection`或者数值型的值如int、double等，还可以是一个自定义的值对象。
2.  **在stream中对元素进行分组** 对stream中的所有task按照TaskType分组。这会生成一个一个`Map<TaskType,List<Task>`,其中的每个entry都包含一个TaskType和与它相关联的Task。也可以使用其它任何的Collection来替代List。如果不需要把所有的task对应到一个TaskType,也可以生成一个`Map<TaskType,Task>`。
3.  **分离stream中的元素** 可以把一个stream分离到两个组中--正在进行中的和已经完成的task。

# 1 Collector in Action #

下面我们通过这个根据type来对task进行分组的例子，来体验`Collector`的作用。在java8中，我们可以像下面这样来实现根据TaskType分组。**请参考博客[day 2][]**

private static Map<TaskType, List<Task>> groupTasksByType(List<Task> tasks) {
        return tasks.stream().collect(Collectors.groupingBy(task -> task.getType()));
    }

上面的代码使用了`Collectors`工具类中定义的`groupingBy` `Collector`方法。它创建一个map，其中key为`TaskType`、value为所有具有相同`TaskType`的task组成的一个list列表。在java7中要实现相同的功能，需要写如下的代码。

public static void main(String[] args) {
        List<Task> tasks = getTasks();
        Map<TaskType, List<Task>> allTasksByType = new HashMap<>();
        for (Task task : tasks) {
            List<Task> existingTasksByType = allTasksByType.get(task.getType());
            if (existingTasksByType == null) {
                List<Task> tasksByType = new ArrayList<>();
                tasksByType.add(task);
                allTasksByType.put(task.getType(), tasksByType);
            } else {
                existingTasksByType.add(task);
            }
        }
        for (Map.Entry<TaskType, List<Task>> entry : allTasksByType.entrySet()) {
            System.out.println(String.format("%s =>> %s", entry.getKey(), entry.getValue()));
        }
    }

# 2 收集器（Collectors）:常用规约操作 #

`      Collectors` 工具类提供了许多静态工具方法来为大多数常用的用户用例创建收集器，比如将元素装进一个集合中、将元素分组、根据不同标准对元素进行汇总等。本文中将覆盖大多数常见的`收集器(Collector)`。

## 2.1 规约到一个单独的值 ##

如上面所说，收集器(collector)可以用来把stream收集到一个collection中或者产生一个单独的值。

### 2.1.1 把数据装进一个list列表中 ###

下面我们给出第一个测试用例--将给定的任务列表的所有标题收集到一个List列表中。

import static java.util.stream.Collectors.toList;
    
    public class Example2_ReduceValue {
        public List<String> allTitles(List<Task> tasks) {
            return tasks.stream().map(Task::getTitle).collect(toList());
        }
    }

`toList`收集器通过使用List的`add`方法将元素添加到一个结果List列表中，`toList`收集器使用`ArrayList`作为List的实现。

### 2.1.2 将数据收集到一个Set中 ###

如果要保证所收集的title不重复并且我们对数据的排序没有要求的话，可以采用`toSet`收集器。

import static java.util.stream.Collectors.toSet;
    
    public Set<String> uniqueTitles(List<Task> tasks) {
        return tasks.stream().map(Task::getTitle).collect(toSet());
    }

`  toSet` 方法采用`HashSet`作为Set的实现来储存结果集。

### 2.1.3 把数据收集到一个Map中 ###

可以使用`toMap`收集器将一个stream转换成一个Map。`toMap`收集器需要两个集合函数来提取map中的key和value。下面的代码中，`Task::getTitle`需要一个task并产生一个仅有一个标题的key。**task -> task是一个用来返回自己的lambda表达式**，上例中返回一个task。

private static Map<String, Task> taskMap(List<Task> tasks) {
      return tasks.stream().collect(toMap(Task::getTitle, task -> task));
    }

可以**使用`Function`接口中的默认方法`identity`**来让上面的代码代码变得更简洁明了、传递开发者意图时更加直接，下面是采用identity函数的代码。

import static java.util.function.Function.identity;
    
    private static Map<String, Task> taskMap(List<Task> tasks) {
      return tasks.stream().collect(toMap(Task::getTitle, identity()));
    }

**代码创建了一个Map，当出现相同的key时就会抛出如下的异常**。

Exception in thread "main" java.lang.IllegalStateException: 
    Duplicate key Task{title='Read Version Control with Git book', type=READING}
    at java.util.stream.Collectors.lambda$throwingMerger$105(Collectors.java:133)

`  toMap`**还有一个可以指定合并函数的变体，我们可以采用它来处理重复的副本**。合并函数允许开发者指定一个解决同一个key冲突的规则。在下面的代码中，我们简单地使用最后一个value，当然你也可以写更加智能的算法来处理冲突。

private static Map<String, Task> taskMap_duplicates(List<Task> tasks) {
      return tasks.stream().collect(toMap(Task::getTitle, identity(), (t1, t2) -> t2));
    }

我们还可以使用`toMap`的第三种变体方法来使用任何其它的Map实现，这需要指定`Map` 和`Supplier`来存放结果。

public Map<String, Task> collectToMap(List<Task> tasks) {
        return tasks.stream().collect(toMap(Task::getTitle, identity(), (t1, t2) -> t2, LinkedHashMap::new));
    }

与`toMap`收集器类似，`toConcurrentMap`收集器可以产生`ConcurrntMap`来替代`HashMap`。

# 3 Using other collections 使用其它的集合 #

`toList`和`toSet`等特定的收集器不支持指定潜在的list或set的实现，当你想要像下面这样这样把结果聚合到其它类型的集合时可以采用`toCollection`收集器。

private static LinkedHashSet<Task> collectToLinkedHaskSet(List<Task> tasks) {
      return tasks.stream().collect(toCollection(LinkedHashSet::new));
    }

### 找出标题最长的task ###

public Task taskWithLongestTitle(List<Task> tasks) {
        return tasks.stream().collect(collectingAndThen(maxBy((t1, t2) -> t1.getTitle().length() - t2.getTitle().length()), Optional::get));
    }

### 统计tags的总数 ###

public int totalTagCount(List<Task> tasks) {
        return tasks.stream().collect(summingInt(task -> task.getTags().size()));
    }

### 生成task标题的汇总 ###

import static java.util.stream.Collectors.joining;
    
    public String titleSummary(List<Task> tasks) {
        return tasks.stream().map(Task::getTitle).collect(joining(";"));
    }

## 将元素分组 ##

Collector收集器一个最常见的用户用例就是对元素进行分组，下面我们通过几个示例来理解我们可以如何来分组。

### Example 1: 根据type对tasks分组 ###

下面这个例子，我们根据`TaskType`对task进行分组。通过使用`Collectors`工具类的`groupingBy`收集器，我们可以非常简单的完成这个功能。可以使用方法引用和静态引入来让代码变得更加简洁。

import static java.util.stream.Collectors.groupingBy;
    private static Map<TaskType, List<Task>> groupTasksByType(List<Task> tasks) {
           return tasks.stream().collect(groupingBy(Task::getType));
    }

会产生如下的输出：

{
    CODING=[
    Task{title='Write a mobile application to store my tasks', type=CODING, createdOn=2015-07-03}], 
    WRITING=[Task{title='Write a blog on Java 8 Streams', type=WRITING, createdOn=2015-07-04}], 
    READING=[Task{title='Read Version Control with Git book', type=READING, createdOn=2015-07-01}, 
    Task{title='Read Java 8 Lambdas book', type=READING, createdOn=2015-07-02}, 
    Task{title='Read Domain Driven Design book', type=READING, createdOn=2015-07-05}
    ]
    }

### Example 2: 根据tags分组 ###

private static Map<String, List<Task>> groupingByTag(List<Task> tasks) {
            return tasks.stream().
                    flatMap(task -> task.getTags().stream().map(tag -> new TaskTag(tag, task))).
                    collect(groupingBy(TaskTag::getTag, mapping(TaskTag::getTask,toList())));
    }
    
        private static class TaskTag {
            final String tag;
            final Task task;
    
            public TaskTag(String tag, Task task) {
                this.tag = tag;
                this.task = task;
            }
    
            public String getTag() {
                return tag;
            }
    
            public Task getTask() {
                return task;
            }
        }

### Example 3: 根据tag和tag的个数分组 ###

private static Map<String, Long> tagsAndCount(List<Task> tasks) {
            return tasks.stream().
            flatMap(task -> task.getTags().stream().map(tag -> new TaskTag(tag, task))).
            collect(groupingBy(TaskTag::getTag, counting()));
        }

### Example 4: 根据TaskType和createdOn分组 ###

private static Map<TaskType, Map<LocalDate, List<Task>>> groupTasksByTypeAndCreationDate(List<Task> tasks) {
            return tasks.stream().collect(groupingBy(Task::getType, groupingBy(Task::getCreatedOn)));
        }

## 分割 ##

有时候，你需要根据一定的规则将一个数据集分成两个数据集。比如，我们可以定义一个分割函数，根据规则`进行时间早于今天和进行时间晚于今天`将task分成两组。

private static Map<Boolean, List<Task>> partitionOldAndFutureTasks(List<Task> tasks) {
      return tasks.stream().collect(partitioningBy(task -> task.getDueOn().isAfter(LocalDate.now())));
    }

## 生成统计 ##

另外，一些产生统计结果的收集器也非常有用。它们主要用于int、double、long等基本类型上，它们可以用来产生类似如下的统计结果。

IntSummaryStatistics summaryStatistics = tasks.stream().map(Task::getTitle).collect(summarizingInt(String::length));
    System.out.println(summaryStatistics.getAverage()); //32.4
    System.out.println(summaryStatistics.getCount()); //5
    System.out.println(summaryStatistics.getMax()); //44
    System.out.println(summaryStatistics.getMin()); //24
    System.out.println(summaryStatistics.getSum()); //162

还有一些其它的基本类型的变体，比如`LongSummaryStatistics` 和 `DoubleSummaryStatistics`

还可以用`combine`操作来把两个`IntSummaryStatistics`结合到一起。

firstSummaryStatistics.combine(secondSummaryStatistics);
    System.out.println(firstSummaryStatistics)

## 把所有的titles连在一起 ##

import static java.util.stream.Collectors.joining;
    
    private static String allTitles(List<Task> tasks) {
      return tasks.stream().map(Task::getTitle).collect(joining(", "));
    }

## 编写一个自定义的收集器 ##

import com.google.common.collect.HashMultiset;
    import com.google.common.collect.Multiset;
    
    import java.util.Collections;
    import java.util.EnumSet;
    import java.util.Set;
    import java.util.function.BiConsumer;
    import java.util.function.BinaryOperator;
    import java.util.function.Function;
    import java.util.function.Supplier;
    import java.util.stream.Collector;
    
    public class MultisetCollector<T> implements Collector<T, Multiset<T>, Multiset<T>> {
    
        @Override
        public Supplier<Multiset<T>> supplier() {
            return HashMultiset::create;
        }
    
        @Override
        public BiConsumer<Multiset<T>, T> accumulator() {
            return (set, e) -> set.add(e, 1);
        }
    
        @Override
        public BinaryOperator<Multiset<T>> combiner() {
            return (set1, set2) -> {
                set1.addAll(set2);
                return set1;
            };
        }
    
        @Override
        public Function<Multiset<T>, Multiset<T>> finisher() {
            return Function.identity();
        }
    
        @Override
        public Set<Characteristics> characteristics() {
            return Collections.unmodifiableSet(EnumSet.of(Characteristics.IDENTITY_FINISH));
        }
    }

import com.google.common.collect.Multiset;
    
    import java.util.Arrays;
    import java.util.List;
    
    public class MultisetCollectorExample {
    
        public static void main(String[] args) {
            List<String> names = Arrays.asList("shekhar", "rahul", "shekhar");
            Multiset<String> set = names.stream().collect(new MultisetCollector<>());
    
            set.forEach(str -> System.out.println(str + ":" + set.count(str)));
    
        }
    }

## Word Count in Java 8 Java8中的单词统计 ##

下面，我们通过java8中的Streams和Collectors编写一个非常著名的单词统计示例来结束本文。

public static void wordCount(Path path) throws IOException {
        Map<String, Long> wordCount = Files.lines(path)
                .parallel()
                .flatMap(line -> Arrays.stream(line.trim().split("\\s")))
                .map(word -> word.replaceAll("[^a-zA-Z]", "").toLowerCase().trim())
                .filter(word -> word.length() > 0)
                .map(word -> new SimpleEntry<>(word, 1))
                .collect(groupingBy(SimpleEntry::getKey, counting()));
        wordCount.forEach((k, v) -> System.out.println(String.format("%s ==>> %d", k, v)));
    }

# 例子 #

Hosting.java

package com.mkyong.java8
    
    public class Hosting {
    
        private int Id;
        private String name;
        private long websites;
    
        public Hosting(int id, String name, long websites) {
            Id = id;
            this.name = name;
            this.websites = websites;
        }
    
        //getters, setters and toString()
    
    }

## 1. List 转换为 Map – Collectors.toMap() ##

创建 `Hosting 的list，使用``Collectors.toMap` 转换为 Map.

TestListMap.java

package com.mkyong.java8

import java.util.ArrayList;  
import java.util.List;  
import java.util.Map;  
import java.util.stream.Collectors;

public class TestListMap \{

public static void main(String\[\] args) \{

List<Hosting> list = new ArrayList<>();  
        list.add(new Hosting(1, "liquidweb.com", 80000));  
        list.add(new Hosting(2, "linode.com", 90000));  
        list.add(new Hosting(3, "digitalocean.com", 120000));  
        list.add(new Hosting(4, "aws.amazon.com", 200000));  
        list.add(new Hosting(5, "mkyong.com", 1));

// key = id, value - websites  
        Map<Integer, String> result1 = **list.stream().collect(Collectors.toMap(Hosting::getId, Hosting::getName));**

System.out.println("Result 1 : " + result1);

// key = name, value - websites  
        Map<String, Long> result2 = list.stream().collect(Collectors.toMap(Hosting::getName, Hosting::getWebsites));

System.out.println("Result 2 : " + result2);

// Same with result1, just different syntax  
        // key = id, value = name  
        Map<Integer, String> result3 = **list.stream().collect(Collectors.toMap(x -> x.getId(), x -> x.getName()));**

System.out.println("Result 3 : " + result3);  
    \}  
\}

输出：

Result 1 : {1=liquidweb.com, 2=linode.com, 3=digitalocean.com, 4=aws.amazon.com, 5=mkyong.com}
    Result 2 : {liquidweb.com=80000, mkyong.com=1, digitalocean.com=120000, aws.amazon.com=200000, linode.com=90000}
    Result 3 : {1=liquidweb.com, 2=linode.com, 3=digitalocean.com, 4=aws.amazon.com, 5=mkyong.com}

## 附加类型转换：int-->string ##

**numbers.stream().map(number -> String.valueOf(number)).collect(Collectors.joining(", "))**

public static void main(String[] argv) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    
        System.out.println(numbers.stream().map(number -> String.valueOf(number)).collect(Collectors.joining(", ")));
      }

List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    
    StringBuilder b = new StringBuilder();
    list.forEach(b::append);
    
    System.out.println(b);
    
    //或者
    
    String s = list.stream().map(Object::toString).collect(Collectors.joining(","));

## 2. List to Map – Duplicated Key! ##

### 2.1 运行下面代码，重复key会报错! ###

TestDuplicatedKey.java

package com.mkyong.java8;

import java.util.ArrayList;  
import java.util.List;  
import java.util.Map;  
import java.util.stream.Collectors;

public class TestDuplicatedKey \{

public static void main(String\[\] args) \{

// key = name, value - websites , but the key 'linode' is duplicated!?  
        Map<String, Long> result1 = **list.stream().collect(Collectors.toMap(Hosting::getName, Hosting::getWebsites));**

System.out.println("Result 1 : " + result1);

\}  
\}

输出–  报错：

Exception in thread "main" java.lang.IllegalStateException: Duplicate key 90000
    	at java.util.stream.Collectors.lambda$throwingMerger$0(Collectors.java:133)
    	at java.util.HashMap.merge(HashMap.java:1245)
    	//...

### 2.2 解决重复key问题，传递处理函数参数： ###

Map<String, Long> result1 = list.stream().collect(  
                **Collectors.toMap(Hosting::getName, Hosting::getWebsites, (oldValue, newValue) -> oldValue)**  
        );

输出：

Result 1 : {..., aws.amazon.com=200000, linode.com=90000}

**注意：**  
**`(oldValue, newValue) -> oldValue` ==> 如果key重复，使用oldKey**

### 3.3 尝试使用newValue ###

Map<String, Long> result1 = list.stream().collect(  
                **Collectors.toMap(Hosting::getName, Hosting::getWebsites,****(oldValue, newValue) -> newvalue****)**  
        );

输出：

Result 1 : {..., aws.amazon.com=200000, linode.com=100000}

## 3. List to Map – Sort & Collect ##

TestSortCollect.java

package com.mkyong.java8;

import java.util.\*;  
import java.util.stream.Collectors;

public class TestSortCollect \{

public static void main(String\[\] args) \{

//example 1  
        Map result1 = list.stream()  
                **.sorted(Comparator.comparingLong(Hosting::getWebsites).reversed())**  
                .collect(  
                        Collectors.toMap(  
                                Hosting::getName, Hosting::getWebsites, // key = name, value = websites  
                                **(oldValue, newValue) -> oldValue,       // if same key, take the old key**  
                                LinkedHashMap::new                       // returns a LinkedHashMap, keep order  
                        ));

System.out.println("Result 1 : " + result1);

\}  
\}

Result 1 : {aws.amazon.com=200000, digitalocean.com=120000, linode.com=100000, liquidweb.com=80000, mkyong.com=1}

*P.S*

*上面例子中, stream在collect前已经被排序了, 所以“linode.com=100000” 已经成为 ‘oldValue’.*

# 枚举例子使用 #

public enum MyCodeEnum {
        ERR_1                ("1", "1 error"),
        ERR_2                ("2", "2 error");
        
        private String code;
        private String message;
    
        MyCodeEnum(String c, String m) {
            code = c;
            message = m;
        }
    
        public String getCode() {
            return code;
        }
    
        public String getMessage() {
            return message;
        }
    
        @Override
        public String toString(){
            return "{code:\""+this.code + "\",message:\"" + this.message + "\"}";
        }
    
        public Map<String, String> toHashMap(){
            return new HashMap<String, String>(){
       {
                put("code", code);
                put("message", message);
            }};
        }
    
        /* Reverse Lookup Implementation */
        private static final Map<String, Map<String, String>> lookup
                = Arrays.asList(values()).stream().collect(toMap(MyCodeEnum::getCode, MyCodeEnum::toHashMap));
    
        public static Map<String, String> getMapValue(String aKey) {
            return lookup.get(aKey);
        }
        
        
        private static final Map<String, String> lookup2
                = Arrays.asList(values()).stream().collect(toMap(MyCodeEnum::getCode, MyCodeEnum::getMessage));
        public static boolean containsKey(String aKey) {
            return lookup2.containsKey(aKey);
        }
        public static String getKeyValue(String aKey) {
            return lookup2.get(aKey);
        }
    }

上面例子中：

**    Arrays.asList(values())**是枚举初始化时将所有枚举都组合成一个list。

##  Java program to convert \`List<Integer>\` to \`List<String>\` ##

**List<String> newList = list.stream()  
                                    .map(s -> String.valueOf(s))  
                                    .collect(Collectors.toList());**

import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
     
    // Java program to convert `List<Integer>` to `List<String>`
    class Main
    {
        // Program to convert `List<Integer>` to `List<String>`
        public static void main(String[] args)
        {
            List<Integer> list = Arrays.asList( 1, 2, 3, 4, 5 );
     
            List<String> newList = list.stream()
                                        .map(s -> String.valueOf(s))
                                        .collect(Collectors.toList());
            System.out.println(newList);
        }
    }

import java.util.Arrays;
    import java.util.List;
    import java.util.function.Function;
    import java.util.stream.Collectors;
     
    // Java program to convert `List<Integer>` to `List<String>`
    class Main
    {
        // Generic method to convert `List<Integer>` to `List<String>`
        public static <T, U> List<U> transform(List<T> list,
                                            Function<T, U> function)
        {
            return list.stream()
                        .map(function)
                        .collect(Collectors.toList());
        }
     
        // Program to convert `List<Integer>` to `List<String>`
        public static void main(String[] args)
        {
            List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
     
            List<String> newList = transform(list, String::valueOf);
            System.out.println(newList);
        }
    }

# 新特性Stream #

# Stream语法讲解 #

Stream执行流程很简单，主要有三个，首先创建一个Stream，然后使用Stream操作数据，最后终止Stream。有点类似于Stream的生命周期。下面我们根据其流程来一个一个讲解。

1、前提准备

首先我们创建一个Student类，以后我们每次都是操作这个类

![java8中一个极其强悍的新特性Stream（非常实用）][java8_Stream]

然后下面我们再创建一个StudentData类，用于获取其数据

![java8中一个极其强悍的新特性Stream（非常实用）][java8_Stream 1]

我们只需要把方法变成static类型的就可以了。

2、创建一个Stream

方式一：通过一个集合创建Stream

![java8中一个极其强悍的新特性Stream（非常实用）][java8_Stream 2]

方式二：通过一个数组创建Stream

![java8中一个极其强悍的新特性Stream（非常实用）][java8_Stream 3]

方式三：通过Stream.of

![java8中一个极其强悍的新特性Stream（非常实用）][java8_Stream 4]

方式四：创建一个无限流

![java8中一个极其强悍的新特性Stream（非常实用）][java8_Stream 5]

3、使用Stream操作数据

操作1：筛选和切片

![java8中一个极其强悍的新特性Stream（非常实用）][java8_Stream 6]

操作2:映射

![java8中一个极其强悍的新特性Stream（非常实用）][java8_Stream 7]

操作3:排序

![java8中一个极其强悍的新特性Stream（非常实用）][java8_Stream 8]

4、终止Stream

操作1：匹配和查找

![java8中一个极其强悍的新特性Stream（非常实用）][java8_Stream 9]

操作2：归约

![java8中一个极其强悍的新特性Stream（非常实用）][java8_Stream 10]

操作3：收集

![java8中一个极其强悍的新特性Stream（非常实用）][java8_Stream 11]

stream基本的语法就是这样，你会发现Stream就像是一个工具一样，可以帮我们分析处理数据，极其的好用，但是目前还不知道其效率如何。根据网上一位大佬的内存时间分析，其实在数据量比较庞大的时候，Stream可以为我们节省大量的时间，数据量小的时候并不明显

# 参考 #

1.  [Java 8 Collectors JavaDoc][]
2.  [Java 8 – How to sort a Map][Java 8 _ How to sort a Map]
3.  [Java 8 Lambda : Comparator example][Java 8 Lambda _ Comparator example]
4.  [https://www.jianshu.com/p/c0d5c3094324][https_www.jianshu.com_p_c0d5c3094324]
5.  [https://www.mkyong.com/java8/java-8-convert-list-to-map/][https_www.mkyong.com_java8_java-8-convert-list-to-map]
6.  [https://www.cnblogs.com/hiver/p/9156147.html][https_www.cnblogs.com_hiver_p_9156147.html]

#  #

# 请我喝咖啡 #

**如果觉得文章写得不错，能对你有帮助，可以扫描我的微信二维码请我喝咖啡～~哈哈~~**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmd5YW5neWU_size_16_color_FFFFFF_t_70][]

[day 2]: https://link.jianshu.com?t=http://shekhargulati.com/2015/07/26/day-2-lets-learn-about-streams/
[java8_Stream]: /images/20211109/668045d70a734ffcbab758b3fbbbf76e.png
[java8_Stream 1]: /images/20211109/bec71aaf75c741f992e4b7edeb90e0a1.png
[java8_Stream 2]: /images/20211109/39ff469359f64deab2b4f669d331531a.png
[java8_Stream 3]: https://imgconvert.csdnimg.cn/aHR0cDovL3AxLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlL2VjNGIwNDc2MWUxNjQxNTRhMmU4ODI3Mjk0NzE1OTA0?x-oss-process=image/format,png
[java8_Stream 4]: /images/20211109/5e0db3619c124cda98d04853633cacf7.png
[java8_Stream 5]: /images/20211109/7beb8a1ef5834091889d40394cd5b059.png
[java8_Stream 6]: /images/20211109/bc902f1ef96e4d3391a3c51da5e11581.png
[java8_Stream 7]: /images/20211109/dda4c66088314d548c56ba2e91a1ac3e.png
[java8_Stream 8]: /images/20211109/05ab1f6a5cf34029924c0673b70d3dc2.png
[java8_Stream 9]: /images/20211109/7ee827d26ff74647a8cad85d43888002.png
[java8_Stream 10]: https://imgconvert.csdnimg.cn/aHR0cDovL3AxLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlLzA1ZDIyZGViZGZkMzRiNDY4YTYzNDdlN2ZjYWI1NTQ5?x-oss-process=image/format,png
[java8_Stream 11]: /images/20211109/0549b8480a0345268de062ca57108dec.png
[Java 8 Collectors JavaDoc]: https://docs.oracle.com/javase/8/docs/api/java/util/stream/Collectors.html
[Java 8 _ How to sort a Map]: http://www.mkyong.com/java8/java-8-how-to-sort-a-map/
[Java 8 Lambda _ Comparator example]: https://www.mkyong.com/java8/java-8-lambda-comparator-example/
[https_www.jianshu.com_p_c0d5c3094324]: https://www.jianshu.com/p/c0d5c3094324
[https_www.mkyong.com_java8_java-8-convert-list-to-map]: https://www.mkyong.com/java8/java-8-convert-list-to-map/
[https_www.cnblogs.com_hiver_p_9156147.html]: https://www.cnblogs.com/hiver/p/9156147.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmd5YW5neWU_size_16_color_FFFFFF_t_70]: /images/20211109/91e7760973ff41bea5a613ffed2e364a.png