java8中stream().map().collect()的Collectors.toList()、Collectors.toMap()、Collectors.groupingBy()方法简介

-`Collectors.tolist()`：
     将流中的元素收集到一个 `List` 中。
-`Collectors.toMap()`：
     将流中的元素收集到一个 `Map` 中，
	   需要提供键和值的映射函数，
	   并可选地提供合并函数来处理键冲突。
-`Collectors.groupingBy()`**：
     按照某个条件将流中的元素分组，生成一个 `Map`，
	   其中键是分组条件的结果，值是符合该条件的元素列表。
	    可以使用下游收集器进一步处理分组后的结果

1.`Collectors.toList()`

功能 
`Collectors.toList()`
  用于将流中的元素收集到一个`List`中 

方法签名
public static <T> Collector<T, ?, List<T>> toList()

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class ToListExample {
    public static void main(String[] args) {
        // 创建一个 Stream
        Stream<String> stream = Stream.of("Apple", "Banana", "Cherry");

        // 使用 Collectors.toList() 将 Stream 转换为 List
        List<String> list = stream.collect(Collectors.toList());

        // 输出 List
        System.out.println("List: " + list);
    }
}

====输出结果

List: [Apple, Banana, Cherry]

2.`Collectors.toMap()`

Collectors.toMap()方法的功能

`Collectors.toMap()`
  用于将流中的元素收集到一个`Map`中
   需要提供两个函数:
      一个用于生成键
	  另一个用于生成值

方法签名

public static <T, K, U> Collector<T, ?, Map<K, U>> toMap(
    Function<? super T, ? extends K> keyMapper,
    Function<? super T, ? extends U> valueMapper)

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

public class ToMapExample {
    public static void main(String[] args) {
        // 创建一个 Stream
        Stream<String> stream = Stream.of("Apple", "Banana", "Cherry");

        // 使用 Collectors.toMap() 将 Stream 转换为 Map
        Map<String, Integer> map = stream.collect(Collectors.toMap(
            s -> s, // 键：字符串本身
            String::length // 值：字符串的长度
        ));

        // 输出 Map
        System.out.println("Map: " + map);
    }
}
 
====输出结果====

Map: {Apple=5, Banana=6, Cherry=6}

注意事项

处理键冲突
     如果流中有重复的键
	    `Collectors.toMap()` 会抛出 `IllegalStateException`
		可以通过提供一个合并函数来处理键冲突。

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

public class ToMapWithMergeExample {
    public static void main(String[] args) {
        // 创建一个 Stream
        Stream<String> stream = Stream.of("Apple", "Banana", "Cherry", "Berry");

        // 使用 Collectors.toMap() 并处理键冲突
        Map<Integer, String> map = stream.collect(Collectors.toMap(
            String::length, // 键：字符串的长度
            s -> s, // 值：字符串本身
            (existing, replacement) -> existing + ", " + replacement // 合并函数
        ));

        // 输出 Map
        System.out.println("Map: " + map);
    }
}

=========输出结果==================

Map: {5=Apple, 6=Banana, Cherry, Berry}

3.`Collectors.groupingBy()`简介

`Collectors.groupingBy()` 
用于将流中的元素按照某个条件分组
生成一个 `Map`，
其中键是分组条件的结果，
值是符合该条件的元素列表。

方法签名
public static <T, K> Collector<T, ?, Map<K, List<T>>>
     groupingBy(Function<? super T, ? extends K> classifier)

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

public class GroupingByExample {
    public static void main(String[] args) {
        // 创建一个 Stream
        Stream<String> stream = Stream.of("Apple", "Banana", "Cherry", "Apricot", "Blueberry");

        // 使用 Collectors.groupingBy() 按照字符串的首字母分组
        Map<Character, List<String>> groupedByFirstLetter = stream.collect(Collectors.groupingBy(
            s -> s.charAt(0) // 分组条件：字符串的首字母
        ));

        // 输出 Map
        System.out.println("Grouped by First Letter: " + groupedByFirstLetter);
    }
}

=============输出结果================

Grouped by First Letter: {A=[Apple, Apricot], B=[Banana, Blueberry], C=[Cherry]}

自定义下游收集器

可使用下游收集器来进一步处理分组后的结果


 例:
   统计每个分组中的元素数量

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

public class GroupingWithDownstreamExample {
    public static void main(String[] args) {
        // 创建一个 Stream
        Stream<String> stream = Stream.of("Apple", "Banana", "Cherry", "Apricot", "Blueberry");

        // 使用 Collectors.groupingBy() 按照字符串的首字母分组，并统计每个分组的数量
        Map<Character, Long> groupedByFirstLetterCount = stream.collect(Collectors.groupingBy(
            s -> s.charAt(0), // 分组条件：字符串的首字母
            Collectors.counting() // 下游收集器：统计数量
        ));

        // 输出 Map
        System.out.println("Grouped by First Letter Count: " + groupedByFirstLetterCount);
    }
}

==============输出结果=================

Grouped by First Letter Count: {A=2, B=2, C=1}