Java Stream Collector自定义实现：灵活构建累加器与收集逻辑

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
    }
}

// ... (在 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
    }
}

// ... (在 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] (顺序可能不同)
    }
}

// ... (在 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] (顺序可能不同)
    }
}