Java Stream Collector 深度解析：自定义累加器与实现技巧-java教程-PHP中文网

java stream collector 深度解析：自定义累加器与实现技巧

本文深入探讨了Java Stream API中Collector的自定义实现，重点介绍了如何利用Collector.of()方法创建高效、灵活的累加器。文章通过多个示例，详细阐述了选择合适的累加器类型（如原生数组、AtomicInteger、匿名类或自定义类）以及如何通过函数引用和Lambda表达式定义其核心操作，旨在帮助开发者掌握构建复杂数据收集逻辑的专业技巧。

理解 Java Stream Collector 的核心机制

Java Stream API 的 Collector 接口是执行终端操作的关键组件，它将流中的元素聚合成一个最终结果。Collector 接口定义了三个泛型类型：Collector<T, A, R>，其中：

T：流中元素的类型。
A：累加器（Accumulator）的类型，它是执行归约操作时用于存储中间结果的可变对象。
R：最终结果的类型。

自定义 Collector 的核心在于实现 Collector.of() 方法，它需要四个基本函数（可选地还可以指定特性）：

supplier()：一个无参数函数，用于创建一个新的空累加器实例。
accumulator()：一个双参数函数，用于将流中的单个元素合并到累加器中。
combiner()：一个双参数函数，用于将两个累加器合并成一个，这在并行流处理中尤为重要。
finisher()：一个单参数函数，用于将累加器中的中间结果转换为最终结果。

理解 A 类型（累加器）的选择和实现是构建高效 Collector 的关键。A 类型可以是任何可变对象，包括原生数组、现有的并发工具类、匿名类，甚至是专门设计的自定义类。

累加器类型 (A) 的选择与实现

在实现自定义 Collector 时，累加器类型 A 的选择至关重要。它决定了中间状态的存储方式以及操作的效率。

立即学习“Java免费学习笔记（深入）”；

1. 使用原生数组或现有可变类型

对于简单的累加操作，例如求和，使用原生数组（如 int[]）或 Java 并发包中的原子类（如 AtomicInteger）作为累加器类型是一种简洁高效的方式。这些类型本身就是可变的，可以直接在 accumulator 和 combiner 函数中进行修改。

示例：整数求和 Collector

以下示例展示了如何使用 int[] 和 AtomicInteger 来实现一个将流中整数求和的 Collector。

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

public class SumCollectors {

    /**
     * 使用 int[] 作为累加器实现整数求和。
     * int[] 的第一个元素用于存储总和。
     *
     * @return 一个 Collector，将 Integer 流求和并返回 Integer。
     */
    public static Collector<Integer, ?, Integer> sumWithIntArray() {
        return Collector.of(
            () -> new int[1], // supplier: 创建一个长度为1的int数组，用于存储和
            (a, i) -> a[0] += i, // accumulator: 将元素i加到数组的第一个元素
            (a, b) -> { a[0] += b[0]; return a; }, // combiner: 合并两个数组的和
            a -> a[0], // finisher: 返回数组的第一个元素作为最终结果
            Collector.Characteristics.UNORDERED // 标识此 Collector 的结果不受处理顺序影响
        );
    }

    /**
     * 使用 AtomicInteger 作为累加器实现整数求和。
     * AtomicInteger 提供了线程安全的累加操作，适用于并行流。
     *
     * @return 一个 Collector，将 Integer 流求和并返回 Integer。
     */
    public static Collector<Integer, ?, Integer> sumWithAtomicInteger() {
        return Collector.of(
            AtomicInteger::new, // supplier: 创建一个新的 AtomicInteger
            AtomicInteger::addAndGet, // accumulator: 将元素加到 AtomicInteger 中
            (a, b) -> { a.addAndGet(b.intValue()); return a; }, // combiner: 合并两个 AtomicInteger 的值
            AtomicInteger::intValue, // finisher: 返回 AtomicInteger 的整数值
            Collector.Characteristics.UNORDERED,
            Collector.Characteristics.CONCURRENT // 标识此 Collector 可以并发执行
        );
    }

    public static void main(String[] args) {
        Stream<Integer> numbers = Stream.of(1, 2, 3, 4, 5);

        Integer sum1 = numbers.collect(sumWithIntArray());
        System.out.println("Sum using int[]: " + sum1); // Output: 15

        Stream<Integer> numbers2 = Stream.of(10, 20, 30);
        Integer sum2 = numbers2.collect(sumWithAtomicInteger());
        System.out.println("Sum using AtomicInteger: " + sum2); // Output: 60
    }
}

登录后复制

注意事项：

int[] 简单高效，但在并行流中需要额外的同步措施，否则可能导致数据不一致。
AtomicInteger 提供了线程安全的累加，非常适合并行流处理，因此可以添加 CONCURRENT 特性。

2. 使用匿名类或内部类作为累加器

当没有现成的类型能够满足复杂的累加需求时，可以考虑使用匿名类或局部内部类作为累加器 A。这种方式避免了创建独立的具名类，将累加器的实现细节封装在 Collector 内部，提高了代码的局部性和可读性。

360智图

AI驱动的图片版权查询平台

143

查看详情

示例：收集具有最大值的键

假设我们需要从 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 MaxKeysCollector {

    /**
     * 使用 AbstractMap.SimpleEntry 作为累加器，收集具有最大值的键。
     * SimpleEntry 的 key 存储键列表，value 存储当前最大值。
     *
     * @param <K> 键的类型
     * @return 一个 Collector，收集 Map.Entry 流中最大值对应的键列表。
     */
    public static <K> Collector<Map.Entry<K, Integer>, ?, List<K>> keysToMaximumWithSimpleEntry() {
        return Collector.of(
            // supplier: 创建一个 SimpleEntry，键为新 ArrayList，值为 Integer.MIN_VALUE
            () -> 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) return b; // b 的最大值更大，返回 b
                if (maxA == maxB) a.getKey().addAll(b.getKey()); // 最大值相同，合并键列表
                return a; // a 的最大值更大或相同，返回 a
            },
            // finisher: 返回 SimpleEntry 中的键列表
            Map.Entry::getKey
        );
    }

    /**
     * 使用匿名类作为累加器，收集具有最大值的键。
     * 匿名类可以更灵活地定义内部状态。
     *
     * @param <K> 键的类型
     * @return 一个 Collector，收集 Map.Entry 流中最大值对应的键列表。
     */
    public static <K> Collector<Map.Entry<K, Integer>, ?, List<K>> keysToMaximumWithAnonymousClass() {
        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: 返回匿名对象中的键列表
            a -> a.keys
        );
    }

    public static void main(String[] args) {
        Map<String, Integer> data = Map.of("A", 10, "B", 20, "C", 20, "D", 5);
        Stream<Map.Entry<String, Integer>> entryStream = data.entrySet().stream();

        List<String> maxKeys1 = entryStream.collect(keysToMaximumWithSimpleEntry());
        System.out.println("Max keys using SimpleEntry: " + maxKeys1); // Output: [B, C]

        Map<String, Integer> data2 = Map.of("X", 100, "Y", 50, "Z", 100);
        Stream<Map.Entry<String, Integer>> entryStream2 = data2.entrySet().stream();
        List<String> maxKeys2 = entryStream2.collect(keysToMaximumWithAnonymousClass());
        System.out.println("Max keys using Anonymous Class: " + maxKeys2); // Output: [X, Z]
    }
}

登录后复制

注意事项：

AbstractMap.SimpleEntry 是一个轻量级的键值对容器，可以方便地存储两个相关联的值。
匿名类提供了一种在不定义具名类的情况下创建复杂累加器的方式，尤其适用于累加器逻辑仅在 Collector 内部使用的情况。

3. 创建独立的累加器类

尽管前面两种方法非常灵活，但在某些情况下，如果累加器需要承载更复杂的业务逻辑或在多个 Collector 中复用，创建一个独立的具名类作为累加器类型 A 也是一个合理的选择。这种方式提供了更好的封装性和可维护性。

示例：自定义 SumCollector 类

在原始问题中，SumCollector 类就是一个典型的例子，它封装了求和的逻辑。

public static class SumCollectorAccumulator {
    Integer value;

    public SumCollectorAccumulator(Integer value) {
        this.value = value;
    }

    public static SumCollectorAccumulator supply() {
        return new SumCollectorAccumulator(0);
    }

    public void accumulate(Integer next) {
        value += next;
    }

    public SumCollectorAccumulator combine(SumCollectorAccumulator other) {
        return new SumCollectorAccumulator(value + other.value);
    }

    public String finish(){
        return Integer.toString(value);
    }
}

// 使用自定义累加器类创建 Collector
public static Collector<Integer, SumCollectorAccumulator, String> customSumCollector() {
    return Collector.of(
        SumCollectorAccumulator::supply,
        SumCollectorAccumulator::accumulate,
        SumCollectorAccumulator::combine,
        SumCollectorAccumulator::finish
    );
}

登录后复制

注意事项：

这种方法使得累加器逻辑清晰地封装在一个类中，但 Collector.of() 的参数仍然需要通过方法引用或 Lambda 表达式来调用这些方法。
如果累加器类只为这一个 Collector 服务，那么使用匿名类或更简单的 int[] 可能是更轻量级的选择。

实现技巧与总结

选择合适的累加器类型： 这是自定义 Collector 的核心。
- 对于简单的数值操作，int[]、long[] 或 AtomicInteger、AtomicLong 是高效的选择。
- 对于需要存储多个相关联值的中间状态，可以考虑 AbstractMap.SimpleEntry 或自定义的匿名类/局部内部类。
- 如果累加器逻辑复杂且可能复用，或者需要更强的封装性，可以创建独立的具名累加器类。
灵活运用函数引用和 Lambda 表达式： Collector.of() 的四个函数参数可以非常简洁地通过方法引用（如 AtomicInteger::new）或 Lambda 表达式（如 (a, i) -> a[0] += i）来定义，这大大提高了代码的可读性和简洁性。
理解 Collector.Characteristics：
- UNORDERED：表示收集操作的结果不受流中元素顺序的影响。
- CONCURRENT：表示累加器可以安全地在并行流中并发地被多个线程修改，通常需要累加器本身是线程安全的（如 AtomicInteger）。
- IDENTITY_FINISH：表示 finisher 函数是一个空操作，即累加器类型 A 与最终结果类型 R 相同。
避免不必要的类创建： 除非有明确的复用或复杂逻辑需求，否则尽量使用内置类型、匿名类或局部内部类来作为累加器，以减少代码量和提高局部性。