Java Collectors：强大的流处理终结操作工具

简介

在 Java 8 引入流（Stream）API 后，编程方式发生了重大变革。Collectors 作为流处理中的关键部分，提供了一种强大而灵活的方式来对数据流进行聚集操作。它可以将流中的元素收集到各种数据结构中，如列表、集合、映射等，还能进行分组、分区、汇总等复杂操作，极大地提升了代码的可读性和性能。

目录

1. 基础概念
   • 什么是 Collectors
   • 与 Stream 的关系
2. 使用方法
   • 收集到集合
   • 收集到映射
   • 分组操作
   • 分区操作
3. 常见实践
   • 计算总和、平均值等
   • 查找最值
4. 最佳实践
   • 性能优化
   • 代码简洁性和可读性提升
5. 小结
6. 参考资料

基础概念

什么是 Collectors

Collectors 是一个工具类，位于 java.util.stream 包中。它包含了一系列静态方法，用于创建各种收集器（Collector）实例。收集器定义了如何将流中的元素累积到一个可变结果容器中，并且可以在收集完成后对结果进行进一步的转换。

与 Stream 的关系

Stream 是一系列支持顺序和并行聚合操作的元素序列。Collectors 通常作为 Stream 的终结操作（terminal operation），用于将流中的元素收集成一个最终的结果。例如：

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

public class CollectorsExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> squaredNumbers = numbers.stream()
              .map(n -> n * n)
              .collect(Collectors.toList());
        System.out.println(squaredNumbers);
    }
}

在这个例子中，Collectors.toList() 作为流操作的终结操作，将流中经过平方计算后的元素收集到一个列表中。

使用方法

收集到集合

• 收集到 List：Collectors.toList() 可以将流中的元素收集到一个 List 中。

List<String> words = Arrays.asList("apple", "banana", "cherry");
List<String> upperCaseWords = words.stream()
      .map(String::toUpperCase)
      .collect(Collectors.toList());
System.out.println(upperCaseWords);

• 收集到 Set：Collectors.toSet() 用于将流中的元素收集到一个 Set 中，自动去除重复元素。

Set<Integer> uniqueNumbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5).stream()
      .collect(Collectors.toSet());
System.out.println(uniqueNumbers);

收集到映射

Collectors.toMap() 可以将流中的元素收集到一个 Map 中。它需要两个参数，一个用于生成键，一个用于生成值。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Map<String, Integer> nameLengthMap = names.stream()
      .collect(Collectors.toMap(name -> name, name -> name.length()));
System.out.println(nameLengthMap);

如果键冲突，可以提供一个合并函数作为第三个参数：

List<String> wordsWithDuplicates = Arrays.asList("apple", "banana", "apple");
Map<String, Integer> wordCountMap = wordsWithDuplicates.stream()
      .collect(Collectors.toMap(
            word -> word,
            word -> 1,
            (count1, count2) -> count1 + count2
      ));
System.out.println(wordCountMap);

分组操作

Collectors.groupingBy() 用于对流中的元素进行分组。它接受一个分类函数，根据函数的返回值将元素分到不同的组中。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Map<Boolean, List<Integer>> evenOddMap = numbers.stream()
      .collect(Collectors.groupingBy(n -> n % 2 == 0));
System.out.println(evenOddMap);

还可以进行多级分组，通过在 groupingBy() 中嵌套调用：

List<String> fruits = Arrays.asList("apple", "banana", "cherry", "kiwi", "lemon");
Map<Integer, Map<Character, List<String>>> lengthAndFirstCharMap = fruits.stream()
      .collect(Collectors.groupingBy(
            String::length,
            Collectors.groupingBy(s -> s.charAt(0))
      ));
System.out.println(lengthAndFirstCharMap);

分区操作

Collectors.partitioningBy() 是一种特殊的分组操作，它基于一个布尔值条件将元素分成两个组，通常用于将元素分为满足条件和不满足条件的两组。

List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6);
Map<Boolean, List<Integer>> partitionedMap = numberList.stream()
      .collect(Collectors.partitioningBy(n -> n > 3));
System.out.println(partitionedMap);

常见实践

计算总和、平均值等

Collectors.summingInt()、Collectors.averagingInt() 等方法可以用于对流中的元素进行数值计算。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
      .collect(Collectors.summingInt(Integer::intValue));
double average = numbers.stream()
      .collect(Collectors.averagingInt(Integer::intValue));
System.out.println("Sum: " + sum);
System.out.println("Average: " + average);

查找最值

Collectors.maxBy() 和 Collectors.minBy() 可以用于查找流中的最大或最小元素。

List<Integer> numberList = Arrays.asList(10, 5, 8, 15, 20);
numberList.stream()
      .collect(Collectors.maxBy(Integer::compareTo))
      .ifPresent(max -> System.out.println("Max: " + max));
numberList.stream()
      .collect(Collectors.minBy(Integer::compareTo))
      .ifPresent(min -> System.out.println("Min: " + min));

最佳实践

性能优化

• 并行流与收集器：在处理大数据集时，使用并行流可以显著提高性能。但要注意收集器的线程安全性，一些收集器（如 Collectors.toList()）在并行流中使用时会有性能开销，应根据具体情况选择合适的收集器。
• 避免不必要的中间操作：减少流中的中间操作，尽量在一次流处理中完成所有必要的转换和收集操作，以减少内存开销和计算时间。

代码简洁性和可读性提升

• 使用方法引用：在收集器的参数中尽量使用方法引用，而不是匿名函数，这样可以使代码更简洁、易读。
• 提取复杂逻辑：如果分类函数或其他逻辑比较复杂，可以将其提取成独立的方法，提高代码的可维护性。

小结

Java Collectors 为流处理提供了丰富而强大的功能，从简单的收集到集合和映射，到复杂的分组、分区和汇总操作。通过合理使用 Collectors，可以使代码更加简洁、高效，提升开发效率和代码质量。理解 Collectors 的基础概念、掌握其使用方法和常见实践，并遵循最佳实践原则，将有助于开发者在日常编程中更好地运用这一强大工具。

参考资料

• Oracle Java Documentation - java.util.stream.Collectors
• 《Effective Java》 Third Edition
• Baeldung - Java Stream Collectors