java stream Interface Collector＜T,A,R＞

最新推荐文章于 2024-06-07 01:26:48 发布

原创最新推荐文章于 2024-06-07 01:26:48 发布 · 728 阅读

2 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#java

本文深入探讨了Java 8中的Collector接口，详细介绍了其工作原理和实现细节，包括Supplier、Accumulator、Combiner及Finisher四个核心方法的作用与协同工作流程。适合希望深入了解Java 8新特性的开发者阅读。

Interface Collector<T,A,R>
T:输入的类型
A:中间存放数据的容器
R:输出的类型

Collector通过下面四个方法协同工作以完成汇聚操作：
supplier：创建新的结果容器
accumulator：将输入元素合并到结果容器中
combiner：合并两个结果容器（并行流使用，将多个线程产生的结果容器合并）
finisher：将结果容器转换成最终的表示

在这里插入图片描述

    @Override
    @SuppressWarnings("unchecked")
    public final <R, A> R collect(Collector<? super P_OUT, A, R> collector) {
        A container;
        if (isParallel()
                && (collector.characteristics().contains(Collector.Characteristics.CONCURRENT))
                && (!isOrdered() || collector.characteristics().contains(Collector.Characteristics.UNORDERED))) {
            container = collector.supplier().get();
            BiConsumer<A, ? super P_OUT> accumulator = collector.accumulator();
            forEach(u -> accumulator.accept(container, u));
        }
        else {
            container = evaluate(ReduceOps.makeRef(collector));
        }
        return collector.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)
               ? (R) container
               : collector.finisher().apply(container);
    }

    public static <T, I> TerminalOp<T, I>
    makeRef(Collector<? super T, I, ?> collector) {
        Supplier<I> supplier = Objects.requireNonNull(collector).supplier();
        BiConsumer<I, ? super T> accumulator = collector.accumulator();
        BinaryOperator<I> combiner = collector.combiner();
        class ReducingSink extends Box<I>
                implements AccumulatingSink<T, I, ReducingSink> {
            @Override
            public void begin(long size) {
                state = supplier.get();
            }

            @Override
            public void accept(T t) {
                accumulator.accept(state, t);
            }

            @Override
            public void combine(ReducingSink other) {
                state = combiner.apply(state, other.state);
            }
        }
        return new ReduceOp<T, I, ReducingSink>(StreamShape.REFERENCE) {
            @Override
            public ReducingSink makeSink() {
                return new ReducingSink();
            }

            @Override
            public int getOpFlags() {
                return collector.characteristics().contains(Collector.Characteristics.UNORDERED)
                       ? StreamOpFlag.NOT_ORDERED
                       : 0;
            }
        };
    }