JavaStreamCollector自定义技巧解析

本篇文章给大家分享《Java Stream自定义Collector实现技巧》，覆盖了文章的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

本文深入探讨Java Stream API中自定义Collector的灵活实现方式。通过Collector.of()方法，我们可以利用数组、AtomicInteger、Map.Entry甚至匿名类作为可变累加类型，避免创建独立的累加器类，从而更简洁高效地定义复杂的收集逻辑，优化流式数据处理。

在Java Stream API中，Collector接口是执行可变结果的归约操作的关键。它定义了如何将流中的元素累积到一个可变容器中，并在必要时将多个容器合并，最终转换为一个最终结果。虽然Java提供了Collectors工具类中的许多预定义收集器，但在面对特定业务逻辑时，我们往往需要实现自定义的Collector。

理解 Collector.of() 方法

Collector接口有三个泛型类型：，分别代表流中元素的类型（T）、可变累加器的类型（A）和最终结果的类型（R）。创建自定义Collector最常用的方法是使用Collector.of()静态工厂方法，它接受以下函数式接口作为参数：

1. supplier(): 一个Supplier，用于创建新的可变结果容器。
2. accumulator(): 一个BiConsumer，用于将单个元素T累积到可变容器A中。
3. combiner(): 一个BinaryOperator，用于将两个可变容器A合并。这在并行流处理中尤为重要。
4. finisher(): 一个Function，用于将累加器A的最终状态转换为最终结果R。
5. characteristics(): 可选参数，Collector.Characteristics枚举，用于提供关于收集器行为的提示，例如UNORDERED（不保证顺序）、IDENTITY_FINISH（finisher是恒等函数）和CONCURRENT（支持并行累积）。

关键在于，传递给Collector.of()的这些函数（supplier、accumulator、combiner、finisher）不需要是累加器类型A的成员方法。它们可以是任何符合函数签名的lambda表达式或方法引用，这为我们提供了极大的灵活性。

灵活选择累加器类型（A）

自定义Collector的核心在于选择或创建合适的累加器类型A。根据收集逻辑的复杂性，我们可以有多种选择。

1. 使用基本类型数组作为简单状态

对于只需要累积少量基本类型数据的场景，使用一个单元素数组（如int[1]）作为累加器A是一种简洁高效的方法。

示例：计算流中整数的和

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

public class CustomCollectorExamples {

    /**
     * 创建一个收集器，计算流中整数的总和。
     * 使用 int[1] 作为可变累加器。
     */
    public static Collector<Integer, ?, Integer> sumIntegers() {
        return Collector.of(
            () -> new int[1],              // supplier: 创建一个包含一个整数的数组，初始值为0
            (a, i) -> a[0] += i,           // accumulator: 将当前整数累加到数组的第一个元素
            (a, b) -> { a[0] += b[0]; return a; }, // combiner: 合并两个数组，将b的值加到a中
            a -> a[0],                     // finisher: 返回数组的第一个元素作为最终结果
            Collector.Characteristics.UNORDERED // 特性：处理顺序不影响结果
        );
    }

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

这里，int[1]作为可变累加器A，其第一个元素用于存储当前的和。这种方式避免了创建额外的包装类。

2. 利用现有工具类作为累加器

Java标准库中提供了许多线程安全或功能丰富的工具类，它们可以直接用作累加器A，特别是在处理并行流时。

示例：使用 AtomicInteger 计算并发流中的和

AtomicInteger是一个线程安全的整数包装类，非常适合在并行流中作为累加器。

// ... (在 CustomCollectorExamples 类中)

    /**
     * 创建一个收集器，计算流中整数的总和，支持并发。
     * 使用 AtomicInteger 作为可变累加器。
     */
    public static Collector<Integer, ?, Integer> concurrentSumIntegers() {
        return Collector.of(
            AtomicInteger::new,                  // supplier: 创建一个新的 AtomicInteger，初始值为0
            AtomicInteger::addAndGet,            // accumulator: 将当前整数添加到 AtomicInteger
            (a, b) -> { a.addAndGet(b.intValue()); return a; }, // combiner: 合并两个 AtomicInteger
            AtomicInteger::intValue,             // finisher: 返回 AtomicInteger 的整数值
            Collector.Characteristics.UNORDERED, // 特性：处理顺序不影响结果
            Collector.Characteristics.CONCURRENT // 特性：支持并发累积
        );
    }

    public static void main(String[] args) {
        // ... (previous main method content)
        Integer concurrentTotalSum = numbers.parallelStream().collect(concurrentSumIntegers());
        System.out.println("Sum of numbers (using AtomicInteger, parallel): " + concurrentTotalSum); // Output: 15
    }
}

通过指定CONCURRENT特性，Collector可以更有效地在并行流中工作。

3. 组合标准库类型作为累加器

当累加器需要存储多个相关值时，可以使用Map.Entry、List或其他标准库中的复合类型。

示例：收集Map中值最大的所有键

假设我们有一个Map，我们想找出所有值等于最大值的键，并以List的形式返回。累加器需要同时存储当前找到的最大值和对应键的列表。AbstractMap.SimpleEntry, Integer>可以作为合适的累加器类型。

// ... (在 CustomCollectorExamples 类中)

    /**
     * 创建一个收集器，从 Map.Entry<K, Integer> 流中找出值最大的所有键。
     * 使用 AbstractMap.SimpleEntry<List<K>, Integer> 作为可变累加器。
     */
    public static <K> Collector<Map.Entry<K, Integer>, ?, List<K>> keysToMaximum() {
        return Collector.of(
            () -> new AbstractMap.SimpleEntry<>(new ArrayList<K>(), Integer.MIN_VALUE), // supplier: 初始列表为空，最大值为 int 最小值
            (current, next) -> { // accumulator: 处理每个 Map.Entry
                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()); // 添加当前键
                }
            },
            (a, b) -> { // combiner: 合并两个累加器
                int maxA = a.getValue();
                int maxB = b.getValue();
                if (maxA <= maxB) { // b 的最大值更大或相等
                    if (maxA == maxB) { // 如果最大值相等，则合并键列表
                        b.getKey().addAll(a.getKey());
                    }
                    return b; // 返回包含更大（或相等）最大值的累加器
                }
                return a; // a 的最大值更大
            },
            Map.Entry::getKey // finisher: 返回累加器中的键列表
        );
    }

    public static void main(String[] args) {
        // ... (previous main method content)
        Map<String, Integer> scores = Map.of("Alice", 90, "Bob", 95, "Charlie", 95, "David", 88);
        List<String> topScorers = scores.entrySet().stream().collect(keysToMaximum());
        System.out.println("Top scorers: " + topScorers); // Output: [Bob, Charlie] (顺序可能不同)
    }
}

4. 使用匿名类作为Ad-hoc累加器类型

当没有合适的现有类型，且累加器逻辑相对复杂时，可以利用匿名内部类（或在Java 16+中使用匿名记录）作为临时的、局部的累加器类型。这种方式将累加器的状态和部分逻辑封装在一起，但又避免了创建独立的具名类文件。

示例：使用匿名类实现收集Map中值最大的所有键

// ... (在 CustomCollectorExamples 类中)

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

    public static void main(String[] args) {
        // ... (previous main method content)
        Map<String, Integer> scores = Map.of("Alice", 90, "Bob", 95, "Charlie", 95, "David", 88);
        List<String> topScorersAnonymous = scores.entrySet().stream().collect(keysToMaximumWithAnonymousClass());
        System.out.println("Top scorers (using anonymous class): " + topScorersAnonymous); // Output: [Bob, Charlie] (顺序可能不同)
    }
}

这种方法在不引入额外具名类的情况下，为复杂的累加状态提供了清晰的封装。

注意事项与最佳实践

1. 无需独立累加器类实现Collector接口： 许多开发者可能会尝试让自定义的累加器类（如问题中的SumCollector）直接实现Collector接口。虽然技术上可行，但这通常会导致方法重复（例如，supplier()方法内部又调用SumCollector::supply），增加了不必要的复杂性。Collector.of()的设计初衷就是将累加逻辑与累加器类型解耦。
2. 选择合适的累加器类型： 优先考虑使用简单数组、Atomic系列、List、Map.Entry等现有类型。只有当这些类型无法满足需求时，才考虑使用匿名类或自定义具名类。
3. 理解 Characteristics：
   • UNORDERED: 收集器不关心流的顺序，这可能允许更积极的优化。
   • IDENTITY_FINISH: finisher函数是一个恒等函数（即Function.identity()），直接返回累加器本身作为结果。这允许Collector跳过finisher阶段，提高效率。
   • CONCURRENT: 累加器支持并发累积，意味着多个线程可以同时调用accumulator。这通常需要累加器本身是线程安全的（如AtomicInteger），并且combiner必须是恒等函数或不执行任何操作。
4. 线程安全： 如果Collector可能用于并行流，确保累加器类型A及其操作是线程安全的。AtomicInteger、ConcurrentHashMap等是很好的选择。对于非线程安全的类型，如ArrayList，在并行流中需要确保合并逻辑正确处理并发问题，或者避免使用CONCURRENT特性。

总结

Java Stream API的Collector.of()方法为自定义数据收集提供了强大的灵活性。通过巧妙地选择累加器类型A，并利用lambda表达式和方法引用实现supplier、accumulator、combiner和finisher，我们可以在不引入额外具名累加器类的情况下，实现各种复杂的流归约操作。掌握这些技巧，能够帮助我们编写出更简洁、高效且可维护的Stream处理代码。

终于介绍完啦！小伙伴们，这篇关于《JavaStreamCollector自定义技巧解析》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布文章相关知识，快来关注吧！