JavaStreamCollector用法全解析

本篇文章主要是结合我之前面试的各种经历和实战开发中遇到的问题解决经验整理的，希望这篇《Java Stream Collector使用详解》对你有很大帮助！欢迎收藏，分享给更多的需要的朋友学习~

本文深入探讨 Java Stream API 中 Collector 的自定义实现，特别关注如何灵活地定义和使用累加器（Accumulator）类型 A。文章将揭示 Collector.of 方法的强大之处，通过多种示例展示如何利用原生数组、现有工具类、AbstractMap.SimpleEntry 甚至匿名内部类作为累加器，从而避免不必要的独立类定义。旨在提供一套专业且实用的指南，帮助开发者高效构建功能强大的自定义 Collector，优化代码结构，提升可读性和维护性。

理解 java.util.stream.Collector

java.util.stream.Collector 是 Java Stream API 的核心组件之一，用于将流中的元素聚合成一个最终结果。它通过 Collector.of 方法进行构建，该方法接收四个函数作为参数，分别定义了聚合过程的四个阶段：

1. supplier: 创建一个新的可变结果容器（accumulator）。
2. accumulator: 将流中的单个元素添加到结果容器中。
3. combiner: 将两个结果容器合并成一个，用于并行流的合并操作。
4. finisher: 对最终结果容器进行转换，得到最终的收集结果。

Collector 接口定义了三个泛型类型：Collector，其中 T 是流中元素的类型，A 是可变的累加器类型（通常是内部实现细节），R 是最终结果的类型。

在实践中，开发者有时会倾向于为累加器 A 创建一个独立的类，然后通过方法引用将其绑定到 Collector.of 的各个函数上。然而，这种做法并非总是必要，Java 提供了更灵活的方式来定义累加器类型，从而简化代码结构。

简化累加器类型：使用原生数组和现有工具类

对于简单的累加操作，我们无需为累加器 A 定义一个全新的类。Java 允许我们使用原生数组或现有的并发工具类作为累加器。

示例一：使用 int[1] 作为累加器实现求和

假设我们需要收集一个整数流的总和。一个简单的 int[1] 数组就可以作为累加器，因为它提供了一个可变的整数存储空间。

import java.util.stream.Collector;
import java.util.stream.Stream;

public class CustomSumCollector {

    /**
     * 创建一个收集器，用于计算整数流的总和并返回 Integer 类型。
     * 累加器类型 A 为 int[1]。
     */
    public static Collector<Integer, ?, Integer> sum() {
        return Collector.of(
            () -> new int[1], // supplier: 创建一个长度为1的int数组作为累加器
            (a, i) -> a[0] += i, // accumulator: 将元素i累加到数组的第一个位置
            (a, b) -> { // combiner: 合并两个累加器
                a[0] += b[0];
                return a;
            },
            a -> a[0], // finisher: 返回数组的第一个位置的值作为最终结果
            Collector.Characteristics.UNORDERED // 标记收集器特性
        );
    }

    public static void main(String[] args) {
        Integer totalSum = Stream.of(1, 2, 3, 4, 5)
                                 .collect(sum());
        System.out.println("Sum using int[1] collector: " + totalSum); // Output: 15
    }
}

在这个例子中，int[1] 作为累加器 A，它是一个可变容器，且无需额外的类定义。Collector.of 中的函数通过 Lambda 表达式直接操作这个数组。

示例二：使用 AtomicInteger 作为累加器实现求和（支持并发）

如果需要在并行流中安全地进行累加，可以使用 AtomicInteger。它本身就是线程安全的，非常适合作为并发累加器。

import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collector;
import java.util.stream.Stream;

public class CustomAtomicSumCollector {

    /**
     * 创建一个收集器，用于计算整数流的总和并返回 Integer 类型。
     * 累加器类型 A 为 AtomicInteger。
     */
    public static Collector<Integer, ?, Integer> sum() {
        return Collector.of(
            AtomicInteger::new, // supplier: 创建一个新的 AtomicInteger
            AtomicInteger::addAndGet, // accumulator: 将元素添加到 AtomicInteger
            (a, b) -> { // combiner: 合并两个 AtomicInteger
                a.addAndGet(b.intValue());
                return a;
            },
            AtomicInteger::intValue, // finisher: 返回 AtomicInteger 的值
            Collector.Characteristics.UNORDERED,
            Collector.Characteristics.CONCURRENT // 标记为并发收集器
        );
    }

    public static void main(String[] args) {
        Integer totalSum = Stream.of(1, 2, 3, 4, 5)
                                 .parallel() // 使用并行流
                                 .collect(sum());
        System.out.println("Sum using AtomicInteger collector (parallel): " + totalSum); // Output: 15
    }
}

AtomicInteger 作为一个现有的工具类，完美地充当了累加器，并且提供了线程安全的 addAndGet 方法，简化了并发场景下的实现。

处理复杂累加状态：无需专用类

当累加器需要存储不止一个简单值，而是多个相关数据时，我们仍然可以避免创建独立的命名类。可以利用 AbstractMap.SimpleEntry 或匿名内部类作为临时的、局部的累加器类型。

示例三：收集最大值对应的键列表（使用 AbstractMap.SimpleEntry）

假设我们有一个 Map.Entry 流，需要找出所有具有最大整数值的键，并将它们收集到一个列表中。累加器需要同时存储当前的最大值和一个键列表。

import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collector;
import java.util.stream.Stream;

public class KeysToMaximumCollector {

    /**
     * 收集器，用于从 Map.Entry 流中找出具有最大整数值的所有键。
     * 累加器类型 A 为 AbstractMap.SimpleEntry<List<K>, Integer>。
     */
    public static <K> Collector<Map.Entry<K, Integer>, ?, List<K>> keysToMaximum() {
        return Collector.of(
            // supplier: 初始化累加器，包含一个空列表和最小整数值
            () -> new AbstractMap.SimpleEntry<>(new ArrayList<K>(), Integer.MIN_VALUE),
            // accumulator: 处理单个元素
            (current, next) -> {
                int max = current.getValue(); // 当前最大值
                int value = next.getValue();  // 当前元素的值
                if (value >= max) {
                    if (value > max) { // 如果发现更大的值，清空列表并更新最大值
                        current.setValue(value);
                        current.getKey().clear();
                    }
                    current.getKey().add(next.getKey()); // 添加键
                }
            },
            // combiner: 合并两个累加器
            (a, b) -> {
                int maxA = a.getValue();
                int maxB = b.getValue();
                if (maxA < maxB) { // 如果b的最大值更大，返回b
                    return b;
                }
                if (maxA == maxB) { // 如果最大值相同，合并键列表
                    a.getKey().addAll(b.getKey());
                }
                return a; // 否则返回a
            },
            // finisher: 返回键列表
            Map.Entry::getKey
        );
    }

    public static void main(String[] args) {
        Map<String, Integer> map = Map.of("A", 10, "B", 20, "C", 15, "D", 20);
        List<String> keys = map.entrySet().stream()
                               .collect(keysToMaximum());
        System.out.println("Keys with maximum value: " + keys); // Output: [B, D] (顺序可能不同)
    }
}

这里，AbstractMap.SimpleEntry, Integer> 作为累加器，巧妙地存储了两个状态：一个 List 用于保存键，一个 Integer 用于保存当前最大值。

示例四：收集最大值对应的键列表（使用匿名内部类）

如果 AbstractMap.SimpleEntry 的结构不完全符合需求，或者为了更好的封装性，可以使用匿名内部类作为累加器类型。这种方式可以定义任意数量的字段和方法，但其作用域仅限于 Collector.of 内部。

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collector;
import java.util.stream.Stream;

public class KeysToMaximumAnonymousCollector {

    /**
     * 收集器，用于从 Map.Entry 流中找出具有最大整数值的所有键。
     * 累加器类型 A 为一个匿名内部类。
     */
    public static <K> Collector<Map.Entry<K, Integer>, ?, List<K>> keysToMaximum() {
        return Collector.of(
            // supplier: 创建匿名内部类实例作为累加器
            () -> new Object() { // 匿名内部类
                int max = Integer.MIN_VALUE;
                final List<K> keys = new ArrayList<>();
            },
            // accumulator: 处理单个元素
            (current, next) -> {
                int value = next.getValue();
                if (value >= current.max) {
                    if (value > current.max) {
                        current.max = value;
                        current.keys.clear();
                    }
                    current.keys.add(next.getKey());
                }
            },
            // combiner: 合并两个匿名内部类累加器
            (a, b) -> {
                if (a.max < b.max) {
                    return b;
                }
                if (a.max == b.max) {
                    a.keys.addAll(b.keys);
                }
                return a;
            },
            // finisher: 返回匿名内部类中的 keys 列表
            a -> a.keys
        );
    }

    public static void main(String[] args) {
        Map<String, Integer> map = Map.of("X", 10, "Y", 30, "Z", 20, "W", 30);
        List<String> keys = map.entrySet().stream()
                               .collect(keysToMaximum());
        System.out.println("Keys with maximum value (anonymous collector): " + keys); // Output: [Y, W] (顺序可能不同)
    }
}

这种方法提供了最大的灵活性，允许我们定义一个完全定制的累加器结构，而无需在文件系统中创建一个新的 .java 文件。

总结与注意事项

通过上述示例，我们可以得出以下关键结论和最佳实践：

1. 累加器函数的灵活性：Collector.of 中的 supplier、accumulator、combiner 和 finisher 函数可以使用 Lambda 表达式或方法引用来实现，它们不强制要求作为累加器类型 A 的实例方法。这种分离使得代码更加简洁和模块化。
2. 选择合适的累加器类型 A：
   • 对于简单的数值累加，考虑使用原生数组（如 int[1]）或 AtomicInteger 等现有工具类。
   • 对于需要存储多个相关状态的情况，可以利用 AbstractMap.SimpleEntry 来封装。
   • 如果需要更复杂的内部状态或行为，而又不想创建独立的命名类，匿名内部类是强大的选择。
3. 何时创建独立的累加器类：只有当累加器的状态非常复杂，并且其内部逻辑（如 accumulate、combine 等）需要被封装成一个可复用的、有明确语义的类时，才考虑创建独立的命名类。在大多数情况下，上述的简化方法已经足够。
4. 理解 Collector 特性：根据收集器的行为，正确标记 Collector.Characteristics（如 UNORDERED, CONCURRENT）有助于 Stream API 进行优化。

掌握这些技巧，将使你在自定义 Collector 时更加得心应手，编写出更高效、更简洁、更具可读性的 Java Stream 代码。

今天带大家了解了的相关知识，希望对你有所帮助；关于文章的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~