深入理解 Java Stream Collector：灵活构建自定义累加器-java教程-PHP中文网

深入理解 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 方法进行构建，该方法接收四个函数作为参数，分别定义了聚合过程的四个阶段：

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

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

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

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

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

立即学习“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<K, Integer> 流，需要找出所有具有最大整数值的键，并将它们收集到一个列表中。累加器需要同时存储当前的最大值和一个键列表。

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<List<K>, Integer> 作为累加器，巧妙地存储了两个状态：一个 List<K> 用于保存键，一个 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 文件。

总结与注意事项

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

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