Collectors 类是用于对流进行收集和汇总的工具类。它提供了许多方法来对流进行分组、统计、转换、分区、连接、归约等操作，使得处理集合类数据变得更加方便。

        在使用 Collectors 类时，我们可以通过调用其中的方法来实现对流的不同处理方式。例如，将流中的元素收集到一个 List 中，可以使用 toList() 方法；按照指定条件进行分组，可以使用 groupingBy() 方法；统计流中的元素个数，可以使用 counting() 方法等等。

        此外，Collectors 类还支持自定义收集器，即我们可以根据自己的需求来编写实现了 Collector 接口的自定义收集器，然后直接在代码中使用。这个功能在一些复杂的应用场景下非常有用。

转换

toList()

  Collectors.toList() 方法是 Java 中 Collectors 类提供的一个用于将流中的元素收集到一个 List 集合中的方法。

List<Integer> list = Stream.of(1, 2, 3, 4, 5)
    .collect(Collectors.toList());

在上面的示例中，我们创建了一个包含 1~5 的整数流，并使用 collect 方法配合 Collectors.toList() 方法将流中的元素收集到一个 List 集合中。最终得到的 list 集合中包含了流中所有的元素，即 {1, 2, 3, 4, 5}。

需要注意的是，Collectors.toList() 方法返回的是一个不可变的 List 集合，因此不能对其进行增删操作，但是其中的元素可以修改。如果我们需要获取一个可修改的 List 集合，可以将其转换为 ArrayList：

List<Integer> list = Stream.of(1, 2, 3, 4, 5)
    .collect(Collectors.toCollection(ArrayList::new));

上述代码中，我们使用 Collectors.toCollection() 方法，并指定要创建的集合类型为 ArrayList，这样就能够得到一个可修改的 List 集合了。

总之，Collectors.toList() 方法在实际开发中非常常用，它可以方便地将流中的元素收集到一个 List 集合中，进一步满足我们对数据的处理需求。

toSet()

Collectors.toSet() 方法是 Java 中 Collectors 类提供的一个用于将流中的元素收集到一个 Set 集合中的方法。

Set<Integer> set = Stream.of(1, 2, 3, 4, 5)
    .collect(Collectors.toSet());

在上面的示例中，我们创建了一个包含 1~5 的整数流，并使用 collect 方法配合 Collectors.toSet() 方法将流中的元素收集到一个 Set 集合中。最终得到的 set 集合中包含了流中所有的元素，即 {1, 2, 3, 4, 5}。

需要注意的是，Collectors.toSet() 方法返回的是一个不可变的 Set 集合，因此不能对其进行增删操作，但是其中的元素可以修改。如果我们需要获取一个可修改的 Set 集合，可以将其转换为 HashSet：

Set<Integer> set = Stream.of(1, 2, 3, 4, 5)
    .collect(Collectors.toCollection(HashSet::new));

上述代码中，我们使用 Collectors.toCollection() 方法，并指定要创建的集合类型为 HashSet，这样就能够得到一个可修改的 Set 集合了。

Collectors.toSet() 方法在实际开发中非常常用，它可以方便地将流中的元素收集到一个 Set 集合中，进一步满足我们对数据的处理需求。

toCollection(Supplier<C> collectionFactory)

Collectors.toCollection(Supplier<C> collectionFactory) 方法是 Java 中 Collectors 类提供的一个用于将流中的元素收集到指定类型的集合中的方法。

该方法接受一个参数，即一个类型为 Supplier<C> 的函数式接口，其中 C 是要创建的集合类型。例如，如果我们想要创建一个 LinkedList 集合，可以这样使用该方法：

List<Integer> list = Stream.of(1, 2, 3, 4, 5)
    .collect(Collectors.toCollection(LinkedList::new));

 在上述示例中，我们使用 Collectors.toCollection() 方法，并传入一个 LinkedList::new 函数，表示创建一个 LinkedList 类型的集合。最终得到的 list 集合中包含了流中所有的元素，即 {1, 2, 3, 4, 5}。

需要注意的是，Collectors.toCollection() 方法返回的是一个可修改的集合，因此可以对其进行增删操作。

总之，Collectors.toCollection() 方法在实际开发中非常常用，它可以方便地将流中的元素收集到指定类型的集合中，进一步满足我们对数据的处理需求。同时，该方法还非常灵活，可以根据实际需要传入不同类型的集合工厂来创建不同类型的集合。

toConcurrentMap

Collectors.toConcurrentMap() 方法是 Java 中 Collectors 类提供的一个用于将流中的元素收集到一个并发 Map 中的方法。它有多个重载形式，其中最简单的形式不需要传入 Map 的实现类型：

ConcurrentMap<Integer, String> concurrentMap = Stream.of("a", "b", "c")
    .collect(Collectors.toConcurrentMap(
        String::length,
        Function.identity()
    ));

在上面的例子中，我们使用 toConcurrentMap() 方法创建了一个并发 Map，它将字符串的长度作为键，字符串本身作为值。具体来说，这个方法接受两个参数：

• 一个函数式接口 keyMapper，表示如何将流中的元素转换成键；
• 一个函数式接口 valueMapper，表示如何将流中的元素转换成值。

对于上述例子中的流，String::length 函数式接口将字符串转换成它的长度，而 Function.identity() 函数式接口则将字符串映射成它本身。因此得到的结果为：

{1=a, 2=b, 3=c}

 需要注意的是，当流中存在重复的键时，toConcurrentMap() 方法将会抛出一个 IllegalStateException 异常。我们可以通过第三个参数指定如何解决重复键的问题。例如，如果我们希望将重复的键对应的值合并成一个字符串，可以这样使用该方法：

ConcurrentMap<Integer, String> concurrentMap = Stream.of("aa", "bbb", "cc")
    .collect(Collectors.toConcurrentMap(
        String::length,
        Function.identity(),
        (s1, s2) -> s1 + "|" + s2
    ));

 在上述例子中，我们传入了一个合并函数 (s1, s2) -> s1 + "|" + s2，如果出现重复的键，则将对应的值进行合并，以 | 分隔。因此得到的结果为：

{2=aa|cc, 3=bbb}

Collectors.toConcurrentMap() 方法在实际开发中非常常用，它可以方便地将流中的元素收集到一个并发 Map 中，并且提供了丰富的方式来处理重复键等问题。

toMap

Collectors.toMap() 方法是 一个用于将流中的元素收集到一个 Map 中的方法。它有多个重载形式，其中最简单的形式不需要传入 Map 的实现类型：

Map<Integer, String> map = Stream.of("a", "b", "c")
    .collect(Collectors.toMap(
        String::length,
        Function.identity()
    ));

在上面的例子中，我们使用 toMap() 方法创建了一个 Map，它将字符串的长度作为键，字符串本身作为值。具体来说，这个方法接受两个参数：

• 一个函数式接口 keyMapper，表示如何将流中的元素转换成键；
• 一个函数式接口 valueMapper，表示如何将流中的元素转换成值。

对于上述例子中的流，String::length 函数式接口将字符串转换成它的长度，而 Function.identity() 函数式接口则将字符串映射成它本身。因此得到的结果为：

{1=a, 2=b, 3=c}

 需要注意的是，当流中存在重复的键时，toMap() 方法将会抛出一个 IllegalStateException 异常。我们可以通过第三个参数指定如何解决重复键的问题。例如，如果我们希望将重复的键对应的值合并成一个字符串，可以这样使用该方法：

Map<Integer, String> map = Stream.of("aa", "bbb", "cc")
    .collect(Collectors.toMap(
        String::length,
        Function.identity(),
        (s1, s2) -> s1 + "|" + s2
    ));

在上述例子中，我们传入了一个合并函数 (s1, s2) -> s1 + "|" + s2，如果出现重复的键，则将对应的值进行合并，以 | 分隔。因此得到的结果为：

{2=aa|cc, 3=bbb}

Collectors.toMap() 方法在实际开发中非常常用，它可以方便地将流中的元素收集到一个 Map 中，并且提供了丰富的方式来处理重复键等问题。

分组

groupingBy(Function<? super T, ? extends K> classifier)

Collectors.groupingBy() 方法是 Java 中 Collectors 类提供的一个用于将流中的元素按照指定的分类器分组的方法。具体来说，该方法接受一个参数：

• 一个函数式接口 classifier，表示如何对流中的元素进行分类。

该方法有两个重载形式，其中最简单的形式只需要传入一个分类器函数：

Map<K, List<T>> map = stream.collect(Collectors.groupingBy(classifier));

其中，

• stream 是待处理的流；
• classifier 是一个函数式接口，用于将流中的每个元素映射为一个分类键 K。

例如，我们有一个字符串列表，并希望按照字符串长度分组：

List<String> list = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");
Map<Integer, List<String>> map = list.stream().collect(Collectors.groupingBy(String::length));

 在上面的代码中，我们使用 String::length 函数式接口将字符串转换为它的长度，并将其作为分类键。运行结果如下：

{3=[date], 5=[apple, cherry], 6=[banana], 10=[elderberry]}

需要注意的是，groupingBy() 方法返回的是一个 Map 对象，其中键是分类键，值则是由该分类键对应的元素构成的列表。在上述例子中，长度为 5 的字符串有两个，因此它们都被加入了同一个列表中。

除了上述方法，Collectors.groupingBy() 方法还提供了第二个参数 downstream，用于进一步对分组的结果进行处理。例如，我们可以使用 Collectors.counting() 方法统计每个分组中元素的数量：

Map<Integer, Long> map = list.stream()
    .collect(Collectors.groupingBy(String::length, Collectors.counting()));

上面的代码中，我们使用 Collectors.counting() 方法作为 downstream 参数，统计了每个分组中元素的数量，并将结果封装为 Long 类型。运行结果如下：

{3=1, 5=2, 6=1, 10=1}

Collectors.groupingBy() 方法是 Java 中非常强大的一种分组操作，它能够对流中的元素按照指定的分类器进行分组，并且支持各种进一步处理方式，例如统计、聚合、排序等。

groupingByConcurrent(Function<? super T, ? extends K> classifier)

  Collectors.groupingByConcurrent() 方法和 Collectors.groupingBy() 方法非常相似，都是用于将流中的元素按照指定的分类器进行分组。和 Collectors.groupingBy() 不同的是，Collectors.groupingByConcurrent() 方法返回的是一个线程安全（concurrent）的 ConcurrentMap 对象。

groupingByConcurrent() 方法的使用方法和 groupingBy() 类似，也有两个重载形式。最简单的形式如下：

ConcurrentMap<K, List<T>> map = stream.collect(Collectors.groupingByConcurrent(classifier));

其中，

• stream 是待处理的流；
• classifier 是一个函数式接口，用于将流中的每个元素映射为一个分类键 K。

例如，我们有一个字符串列表，并希望按照字符串长度分组：

List<String> list = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");
ConcurrentMap<Integer, List<String>> map = list.parallelStream()
    .collect(Collectors.groupingByConcurrent(String::length));

在上面的代码中，我们使用 parallelStream() 方法将列表转换为一个并行流，以便在多线程环境下进行分组操作。运行结果如下：

{3=[date], 5=[apple, cherry], 6=[banana], 10=[elderberry]}

        需要注意的是，groupingByConcurrent() 方法和 groupingBy() 方法一样，返回的是一个 Map 对象，其中键是分类键，值则是由该分类键对应的元素构成的列表。在上述例子中，长度为 5 的字符串有两个，因此它们都被加入了同一个列表中。

  Collectors.groupingByConcurrent() 方法和 Collectors.groupingBy() 方法非常相似，可以看作是线程安全版和非线程安全版的分组操作。在多线程环境下，groupingByConcurrent() 方法具有更好的性能和并发能力，适合于处理大规模数据和高并发场景，但相应地会占用更多的系统资源。

mapping()

   Collectors.mapping() 方法是 Java 8 中新增的一个收集器（Collector）。它可以用于对流中的元素进行映射后，再使用其他收集器进行处理。

mapping() 方法的定义如下：

public static <T, U, A, R> Collector<T, ?, R> mapping(
    Function<? super T, ? extends U> mapper,
    Collector<? super U, A, R> downstream)

其中，

• mapper 是一个函数式接口，用于将流中的每个元素进行映射；
• downstream 是另一个收集器，用于对映射后的元素进行进一步的操作。

  mapping() 方法会对流中的元素应用 mapper 函数，并将结果传递给 downstream 收集器进行进一步处理。最终将结果进行合并，形成最终的结果。

        例如，我们有一个字符串列表，并希望统计每个字符串中字符的出现次数。可以使用 mapping() 方法将每个字符串映射为一个字符出现次数的 Map 对象，然后使用 toMap() 方法对所有的 Map 进行合并得到最终的结果：

List<String> list = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");

Map<Character, Integer> resultMap = list.stream()
    .flatMapToInt(String::chars)     // 将每个字符串转换为字符流
    .mapToObj(c -> (char) c)         // 将每个字符转换为包装类型
    .collect(Collectors.mapping(
        Function.identity(),         // 将字符作为 KEY
        Collectors.groupingBy(c -> c, Collectors.summingInt(c -> 1)) // 统计每个字符出现的次数
    ))
    .entrySet().stream()
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

        在上述代码中，我们首先使用 flatMapToInt() 方法将字符串转换为一个 IntStream 对象，然后使用 mapToObj() 方法将每个字符转换为包装类型。接着我们使用 mapping() 方法对每个字符进行了分组统计，得到了多个 Map 对象，最后使用 toMap() 方法将它们合并得到最终的结果。

        需要注意的是，在 mapping() 方法中，我们传递给第二个参数的是 Collectors.groupingBy() 方法，这表示我们先对元素进行了分组操作。而 groupingBy() 方法的第二个参数则是 Collectors.summingInt() 方法，表示我们对每组元素进行求和操作。

  Collectors.mapping() 方法非常灵活，可以与其他的收集器配合使用，实现更加复杂的数据处理操作

分区

partitioningBy(Predicate<? super T> predicate)

        Collectors.partitioningBy(Predicate<? super T> predicate) 是 Java 8 中的一个收集器 (Collector)，它用于将 Stream 中的元素按照 Predicate 的条件进行分区，并将分区的结果保存到一个 Map 对象中。

        该方法的参数 predicate 是一个谓词 (Predicate)，它表示对 Stream 中的元素进行筛选的条件，它的返回值是一个布尔类型。具体来说，如果该方法返回 true，则该元素应该被分到分区的 true 列表中；如果返回 false，则该元素应该被分到分区的 false 列表中。

        例如，假设有一个 Student 类型的列表 List<Student> students，我们可以使用 Collectors.partitioningBy() 方法将其按照学生的分数是否大于等于 60 分进行分区，并将分区的结果保存到一个 Map 对象中：

Map<Boolean, List<Student>> result = students.stream()
    .collect(Collectors.partitioningBy(s -> s.getScore() >= 60));

         上述代码中，我们通过 stream() 方法将 List 转换为 Stream，然后使用 Collectors.partitioningBy() 方法对 Stream 中的元素进行分区，将分区的结果保存到 Map<Boolean, List<Student>> 类型的 result 对象中。最终得到的 Map 对象中，键为 true 的部分包含了所有分数大于等于 60 分的学生，键为 false 的部分包含了所有分数小于 60 分的学生。

        当我们需要将 Stream 中的元素按照某一个属性进行分区时，可以使用方法引用的方式来代替 Lambda 表达式。例如，假设 Student 类型具有一个 boolean 类型的属性 isMale，表示该学生是否为男性，我们可以通过以下代码对学生进行分区：

Map<Boolean, List<Student>> result = students.stream()
    .collect(Collectors.partitioningBy(Student::isMale));

        上述代码中，Student::isMale 表示 Student 类型中的一个静态方法，用于返回该学生是否为男性。因此，我们可以将该方法作为 Predicate 参数传递给 Collectors.partitioningBy() 方法，实现按照学生的性别进行分区的功能。

        总之，Collectors.partitioningBy(Predicate<? super T> predicate) 是 Java 8 中一个非常有用的收集器，它可以将 Stream 中的元素按照任意的条件进行分区，并将分区的结果保存到一个 Map 对象中，为我们处理数据提供了很大的便利性。

partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream)

        Collectors.partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream) 是 Java 8 中的一个收集器 (Collector)，它用于将 Stream 中的元素按照 Predicate 的条件进行分区，并对每个分区应用一个下游收集器 (downstream)，将分区的结果保存到一个 Map 对象中。

        该方法的第一个参数 predicate 是一个谓词 (Predicate)，表示对 Stream 中的元素进行筛选的条件。对符合条件的元素，将被分到分区的 true 列表中；反之，将被分到分区的 false 列表中。

        第二个参数 downstream 是一个下游收集器 (Collector)，它将作用于每个分区的元素上。downstream 接收的类型为 T，中间累加结果的类型为 A，最终的返回值类型为 D。通常情况下，我们使用其他的收集器来作为 downstream，例如 Collectors.toList()、Collectors.toSet()、Collectors.summingInt() 等方法。

        下面，我们通过一个例子来解释 Collectors.partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream) 的用法。假设有一个 Person 类型的列表 List<Person> persons，我们需要将其中年龄大于等于 18 岁的人按照性别进行分区，并将每个分区中的人的姓名保存到一个 List<String> 中。可以采用如下代码实现：

Map<Boolean, List<String>> result = persons.stream()
    .collect(Collectors.partitioningBy(
        p -> p.getAge() >= 18,
        Collectors.mapping(Person::getName, Collectors.toList())));

        上述代码中，我们通过 stream() 方法将 List 转换为 Stream，然后使用 Collectors.partitioningBy() 方法对 Stream 中的元素进行分区，并将分区的结果保存到 Map<Boolean, List<String>> 类型的 result 对象中。其中，第一个参数 p -> p.getAge() >= 18 表示对年龄大于等于 18 的人进行分区，第二个参数 Collectors.mapping(Person::getName, Collectors.toList()) 表示将分区中的每个人的姓名映射到一个 List 中，并将这个 List 作为分区的值。通过这种方式，我们可以实现按照年龄和性别进行分区，并获取每个分区中的人的姓名列表。

        总之，Collectors.partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream) 是 Java 8 中一个非常有用的收集器，它可以将 Stream 中的元素按照任意的条件进行分区，并对每个分区应用一个下游收集器，将分区的结果保存到一个 Map 对象中，为我们处理数据提供了很大的便利性。同时，通过合理选择下游收集器，我们可以实现更加复杂的分区操作。