Java8 Collectors类详解（一）

冷不防 2023-10-13 07:48 18阅读 0赞

`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`，表示如何将流中的元素转换成值。

{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 对象中，为我们处理数据提供了很大的便利性。同时，通过合理选择下游收集器，我们可以实现更加复杂的分区操作。

###  ###