JDK-集合流

归档

• GitHub: JDK-集合流

使用示例

• https://github.com/zengxf/small-frame-demo/blob/master/jdk-demo/simple-demo/src/main/java/test/new_features/jdk1_8/stream/TestStream.java
• 基础方法使用测试：test_base()

JDK 版本

openjdk version "17" 2021-09-14
OpenJDK Runtime Environment (build 17+35-2724)
OpenJDK 64-Bit Server VM (build 17+35-2724, mixed mode, sharing)

原理

数据结构

// 刚开始组装的是双向链表，
//     上游(previousStage) <-> 下游(nextStage)
//     结构如下：
Head(List) <-> filter <-> map <-> skip <-> peek <-> sorted <-> limit <-> forEach

// 调用终止符 forEach() 方法后，组装的 Sink 是单向链表，
//     当前 -> 下游(downstream)
//     结构如下：
Head(List) -> filter -> map -> skip -> peek -> sorted -> limit -> forEach

类结构

• java.util.stream.ReferencePipeline.Head

    /** sign_c_010 流水线-头(首节点、最上游的数据源) */
    static class Head<E_IN, E_OUT> extends ReferencePipeline<E_IN, E_OUT> { // 继承 sign_c_020
        Head(Spliterator<?> source, int sourceFlags, boolean parallel) {
            super(source, sourceFlags, parallel); // sign_cm_020
        }
    }

• java.util.stream.ReferencePipeline.StatelessOp

    /** sign_c_011 无状态操作节点 */
    abstract static class StatelessOp<E_IN, E_OUT>
            extends ReferencePipeline<E_IN, E_OUT> 
    {
        // sign_cm_010 构造器 (用于设置上游) 
        StatelessOp(AbstractPipeline<?, E_IN, ?> upstream, StreamShape inputShape, int opFlags) {
            super(upstream, opFlags); // sign_cm_021
            assert upstream.getOutputShape() == inputShape;
        }
    }

• java.util.stream.ReferencePipeline

/** sign_c_020 引用类型流水线 */
abstract class ReferencePipeline<P_IN, P_OUT>
        extends AbstractPipeline<P_IN, P_OUT, Stream<P_OUT>> // 继承 sign_c_030
        implements Stream<P_OUT>  
{
    // sign_cm_020 构造器 (专用于设置源) 
    ReferencePipeline(Spliterator<?> source, int sourceFlags, boolean parallel) {
        super(source, sourceFlags, parallel); // sign_cm_030
    }

    // sign_cm_021 构造器 (专用于设置上游) 
    ReferencePipeline(AbstractPipeline<?, P_IN, ?> upstream, int opFlags) {
        super(upstream, opFlags); // sign_cm_031
    }

    // sign_am_010 创建并组装 Sink 链节点
    abstract Sink<E_IN> opWrapSink(int flags, Sink<E_OUT> sink);
}

• java.util.stream.AbstractPipeline

/** sign_c_030 基础流水线 (链表节点) */
abstract class AbstractPipeline<E_IN, E_OUT, S extends BaseStream<E_OUT, S>>
        extends PipelineHelper<E_OUT> implements BaseStream<E_OUT, S> 
{
    private final AbstractPipeline sourceStage;     // 数据源节点
    private final AbstractPipeline previousStage;   // 上游节点 (与 nextStage 组成双向链表)
    private AbstractPipeline nextStage;
    private int depth;          // 深度 (相当于第几个节点)
    private Spliterator<?> sourceSpliterator;       // 数据源
    private boolean parallel;   // 并行标识

    // sign_cm_030 构造器 (专用于设置源) 
    AbstractPipeline(Supplier<? extends Spliterator<?>> source, int sourceFlags, boolean parallel) {
        this.previousStage = null;      // 上游节点为空
        this.sourceSupplier = source;   // 保存源数据
        this.sourceStage = this;        // 设置源节点为自己
        this.sourceOrOpFlags = sourceFlags & StreamOpFlag.STREAM_MASK;
        this.combinedFlags = (~(sourceOrOpFlags << 1)) & StreamOpFlag.INITIAL_OPS_VALUE;
        this.depth = 0;                 // 深度为 0
        this.parallel = parallel;
    }

    // sign_cm_031 构造器 (专用于设置上游) 
    AbstractPipeline(AbstractPipeline<?, E_IN, ?> previousStage, int opFlags) {
        if (previousStage.linkedOrConsumed)
            throw new IllegalStateException(MSG_STREAM_LINKED); // 防重复添加
        previousStage.linkedOrConsumed = true;  // 设置已被添加
        previousStage.nextStage = this;         // 将上游节点的下游设置为自己

        this.previousStage = previousStage;     // 设置上游节点
        this.sourceOrOpFlags = opFlags & StreamOpFlag.OP_MASK;
        this.combinedFlags = StreamOpFlag.combineOpFlags(opFlags, previousStage.combinedFlags);
        this.sourceStage = previousStage.sourceStage; // 从上游查找源节点 (相当于是头节点)
        if (opIsStateful())
            sourceStage.sourceAnyStateful = true;
        this.depth = previousStage.depth + 1;   // 深度(递增)加 1
    }
}

• java.util.stream.Sink.ChainedReference

    /*** sign_c_040 引用链 */
    abstract static class ChainedReference<T, E_OUT> implements Sink<T> {
        protected final Sink<? super E_OUT> downstream; // 下游节点
        // 构造器 (只记录下游节点)
        public ChainedReference(Sink<? super E_OUT> downstream) {
            this.downstream = Objects.requireNonNull(downstream);
        }
    }

调用链

xxList.stream()

• java.util.Collection

    default Stream<E> stream() {
        /**
         * stream() 创建流 sign_m_010
         */
        return StreamSupport.stream(spliterator(), false);
    }

    @Override
    default Spliterator<E> spliterator() {
        // 将当前 list 作为数据源
        return Spliterators.spliterator(this, 0); // sign_m_011
    }

• java.util.Spliterators

    // sign_m_011 创建源
    public static <T> Spliterator<T> spliterator(Collection<? extends T> c,
                                                 int characteristics) {
        return new IteratorSpliterator<>(Objects.requireNonNull(c),
                                         characteristics);
    }

• java.util.stream.StreamSupport

    // sign_m_010 创建流
    public static <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel) {
        Objects.requireNonNull(spliterator);
        return new ReferencePipeline.Head<>(spliterator, // 创建头节点 sign_c_010
                                            StreamOpFlag.fromCharacteristics(spliterator),
                                            parallel);
    }

stream.filter()

• java.util.stream.ReferencePipeline

    // 过滤
    @Override
    public final Stream<P_OUT> filter(Predicate<? super P_OUT> predicate) {
        Objects.requireNonNull(predicate);
        /**
         * 创建一个匿名无状态操作节点 sign_c_011
         * 
         * 将自己作为新节点的上游，同时将新节点作为自己的下游 sign_cm_010 sign_cm_031
         */
        return new StatelessOp<P_OUT, P_OUT>(this, StreamShape.REFERENCE, 
                                            StreamOpFlag.NOT_SIZED) {
            @Override // 只重写 opWrapSink 方法 sign_am_010
            Sink<P_OUT> opWrapSink(int flags, Sink<P_OUT> sink) {
                // 创建(引用类型) Sink 链节点 sign_c_040
                return new Sink.ChainedReference<P_OUT, P_OUT>(sink) {
                    @Override
                    public void begin(long size) {
                        downstream.begin(-1);
                    }

                    @Override
                    public void accept(P_OUT u) {
                        if (predicate.test(u))      // 过滤判断
                            downstream.accept(u);   // 满足条件的才给下游消费
                    }
                };
            }
        };
    }

stream.map()

• java.util.stream.ReferencePipeline

    // 转换类型
    @Override
    public final <R> Stream<R> map(Function<? super P_OUT, ? extends R> mapper) {
        Objects.requireNonNull(mapper);
        // 创建一个无状态操作节点 sign_c_011
        return new StatelessOp<P_OUT, R>(this, StreamShape.REFERENCE,
                                        StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
            @Override
            Sink<P_OUT> opWrapSink(int flags, Sink<R> sink) {
                return new Sink.ChainedReference<P_OUT, R>(sink) {
                    @Override
                    public void accept(P_OUT u) {
                        downstream.accept(mapper.apply(u)); // 转换类型并传递给下游节点
                    }
                };
            }
        };
    }

stream.skip()

• java.util.stream.ReferencePipeline

    // 跳过 n 个
    @Override
    public final Stream<P_OUT> skip(long n) {
        if (n < 0)
            throw new IllegalArgumentException(Long.toString(n));
        if (n == 0)
            return this;
        else
            return SliceOps.makeRef(this, n, -1);   // sing_m_041
    }

• java.util.stream.SliceOps

    // sing_m_041
    public static <T> Stream<T> makeRef(AbstractPipeline<?, T, ?> upstream,
                                        long skip, long limit) {
        ... // 省略校验
        long normalizedLimit = limit >= 0 ? limit : Long.MAX_VALUE;

        // 创建一个无状态操作节点 sign_c_011
        return new ReferencePipeline.StatefulOp<T, T>(upstream, StreamShape.REFERENCE,
                                                      flags(limit)) {

            ... // 省略 exactOutputSize opEvaluateParallelLazy opEvaluateParallel

            @Override
            Sink<T> opWrapSink(int flags, Sink<T> sink) {
                return new Sink.ChainedReference<>(sink) {
                    long n = skip;
                    long m = normalizedLimit;

                    @Override
                    public void begin(long size) {
                        downstream.begin(calcSize(size, skip, m));
                    }

                    @Override
                    public void accept(T t) {
                        if (n == 0) {
                            if (m > 0) {
                                m--;    // 2. 再进行限制处理
                                downstream.accept(t);   // 3. 传递给下游
                            }
                        }
                        else {
                            n--;        // 1. 先进行跳过处理
                        }
                    }

                    @Override
                    public boolean cancellationRequested() {
                        return m == 0 || downstream.cancellationRequested();
                    }
                };
            }
        };
    }

stream.peek()

• java.util.stream.ReferencePipeline

    // 检查
    @Override
    public final Stream<P_OUT> peek(Consumer<? super P_OUT> action) {
        Objects.requireNonNull(action);
        return new StatelessOp<P_OUT, P_OUT>(this, StreamShape.REFERENCE, 0) {
            @Override
            Sink<P_OUT> opWrapSink(int flags, Sink<P_OUT> sink) {
                return new Sink.ChainedReference<P_OUT, P_OUT>(sink) {
                    @Override
                    public void accept(P_OUT u) {
                        action.accept(u);       // 消费
                        downstream.accept(u);   // 传递给下游
                    }
                };
            }
        };
    }

stream.sorted()

• java.util.stream.ReferencePipeline

    // 排序
    @Override
    public final Stream<P_OUT> sorted() {
        return SortedOps.makeRef(this); // sign_m_061
    }

• java.util.stream.SortedOps

    // sign_m_061
    static <T> Stream<T> makeRef(AbstractPipeline<?, T, ?> upstream) {
        return new OfRef<>(upstream); // sign_cm_061
    }

• java.util.stream.SortedOps.OfRef

    /** 排序-有状态节点 */
    private static final class OfRef<T> extends ReferencePipeline.StatefulOp<T, T> {
        private final boolean isNaturalSort;
        private final Comparator<? super T> comparator;

        // sign_cm_061
        OfRef(AbstractPipeline<?, T, ?> upstream) {
            super(upstream, StreamShape.REFERENCE,
                  StreamOpFlag.IS_ORDERED | StreamOpFlag.IS_SORTED);
            this.isNaturalSort = true;
            // Will throw CCE when we try to sort if T is not Comparable
            @SuppressWarnings("unchecked")
            Comparator<? super T> comp = (Comparator<? super T>) Comparator.naturalOrder();
            this.comparator = comp;
        }

        @Override
        public Sink<T> opWrapSink(int flags, Sink<T> sink) {
            Objects.requireNonNull(sink);

            if (StreamOpFlag.SORTED.isKnown(flags) && isNaturalSort)
                return sink;
            else if (StreamOpFlag.SIZED.isKnown(flags))
                return new SizedRefSortingSink<>(sink, comparator);
            else
                return new RefSortingSink<>(sink, comparator);  // 调试进入此 sign_cm_062
        }
    }

• java.util.stream.SortedOps.RefSortingSink

    /** 排序 Sink 节点 */
    private static final class RefSortingSink<T> extends AbstractRefSortingSink<T> { // 继承 sign_c_064
        private ArrayList<T> list;      // 缓存集合

        // sign_cm_062
        RefSortingSink(Sink<? super T> sink, Comparator<? super T> comparator) {
            super(sink, comparator);    // sign_cm_064
        }

        @Override
        public void begin(long size) {
            ... // 省略校验
            list = (size >= 0) ? new ArrayList<>((int) size) : new ArrayList<>();   // 初始化集合
        }

        @Override
        public void end() {
            list.sort(comparator);  // 排序
            downstream.begin(list.size());
            if (!cancellationRequestedCalled) {
                list.forEach(downstream::accept);   // 传给下游
            }
            else {
                for (T t : list) {
                    if (downstream.cancellationRequested()) break;
                    downstream.accept(t);
                }
            }
            downstream.end();
            list = null;
        }

        @Override
        public void accept(T t) {
            list.add(t);    // 添加到自己的缓存集合
        }
    }

• java.util.stream.SortedOps.AbstractRefSortingSink

    /** sign_c_064 抽象排序 Sink 链节点 */
    private abstract static class AbstractRefSortingSink<T> extends Sink.ChainedReference<T, T> { // 继承 sign_c_040
        protected final Comparator<? super T> comparator;   // 排序使用的比较器

        // sign_cm_064
        AbstractRefSortingSink(Sink<? super T> downstream, Comparator<? super T> comparator) {
            super(downstream);
            this.comparator = comparator;
        }
    }

stream.limit()

• java.util.stream.ReferencePipeline

    // 限制 n 个 (逻辑同 skip)
    @Override
    public final Stream<P_OUT> limit(long maxSize) {
        if (maxSize < 0)
            throw new IllegalArgumentException(Long.toString(maxSize));
        return SliceOps.makeRef(this, 0, maxSize);  // 用的是 skip 相同的逻辑: sing_m_041
    }

stream.forEach()

• java.util.stream.ReferencePipeline

    @Override
    public void forEach(Consumer<? super P_OUT> action) {
        /**
         * makeRef() 返回 Sink 链节点 sign_m_090
         * 
         * evaluate() 父类方法(相当于执行整个流的相关操作) sign_m_095
         */
        evaluate(ForEachOps.makeRef(action, false));
    }

• java.util.stream.ForEachOps

final class ForEachOps {
    // sign_m_090
    public static <T> TerminalOp<T, Void> makeRef(Consumer<? super T> action,
                                                  boolean ordered) {
        Objects.requireNonNull(action);
        return new ForEachOp.OfRef<>(action, ordered);  // sign_cm_092
    }

    abstract static class ForEachOp<T>
            implements TerminalOp<T, Void>, TerminalSink<T, Void>
    {
        private final boolean ordered; // 指示并行流，是否需要保持有序

        // sign_cm_091
        protected ForEachOp(boolean ordered) {
            this.ordered = ordered;
        }

        // sign_m_100 串行操作流
        @Override
        public <S> Void evaluateSequential(PipelineHelper<T> helper,
                                           Spliterator<S> spliterator) {
            return helper.wrapAndCopyInto(this, spliterator).get(); // 对流反向调用一次 sign_m_110
        }

        static final class OfRef<T> extends ForEachOp<T> {
            final Consumer<? super T> consumer;

            // sign_cm_092 构造器
            OfRef(Consumer<? super T> consumer, boolean ordered) {
                super(ordered); // sign_cm_091
                this.consumer = consumer;
            }

            @Override
            public void accept(T t) {
                consumer.accept(t); // 直接让传入的(参数)消费者消费
            }
        }
    }
}

• java.util.stream.AbstractPipeline

    // sign_m_095 执行整个流的相关操作
    final <R> R evaluate(TerminalOp<E_OUT, R> terminalOp) {
        assert getOutputShape() == terminalOp.inputShape();
        if (linkedOrConsumed) // 防重复操作(一个流只能执行一次终止符操作)
            throw new IllegalStateException(MSG_STREAM_LINKED);
        linkedOrConsumed = true;

        /**
         * 示例用的是串行流，调用 evaluateSequential() 方法，参考: sign_m_100
         */
        return isParallel()
               ? terminalOp.evaluateParallel(this, sourceSpliterator(terminalOp.getOpFlags()))
               : terminalOp.evaluateSequential(this, sourceSpliterator(terminalOp.getOpFlags()));
    }

    // 获取源数据
    private Spliterator<?> sourceSpliterator(int terminalFlags) {
        Spliterator<?> spliterator = null;
        if (sourceStage.sourceSpliterator != null) {
            spliterator = sourceStage.sourceSpliterator; // 从头节点查找数据源
            sourceStage.sourceSpliterator = null;
        }
        ... // 省略其他获取和校验

        ... // 省略并行处理

        ... // 省略标识符处理

        return spliterator;
    }

    // sign_m_110 流处理
    @Override
    final <P_IN, S extends Sink<E_OUT>> S wrapAndCopyInto(S sink, Spliterator<P_IN> spliterator) {
        /**
         * wrapSink() 组装 Sink 链。 ref: sign_m_111
         * 
         * copyInto() 将源传给流进行操作。 ref: sign_m_112
         */
        copyInto(wrapSink(Objects.requireNonNull(sink)), spliterator);
        return sink;
    }

    // sign_m_112
    @Override
    final <P_IN> void copyInto(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator) {
        Objects.requireNonNull(wrappedSink);

        if (!StreamOpFlag.SHORT_CIRCUIT.isKnown(getStreamAndOpFlags())) {
            wrappedSink.begin(spliterator.getExactSizeIfKnown());
            spliterator.forEachRemaining(wrappedSink);
            wrappedSink.end();
        }
        else { // 进入此
            copyIntoWithCancel(wrappedSink, spliterator); // sign_m_113
        }
    }

    // sign_m_111 组装 Sink 链
    @Override
    final <P_IN> Sink<P_IN> wrapSink(Sink<E_OUT> sink) {
        Objects.requireNonNull(sink);
        for (AbstractPipeline p = AbstractPipeline.this; p.depth > 0; p = p.previousStage) {
            /**
             * 从流的尾节点开始，向上依次调用(创建并组装 Sink 链) sign_am_010
             * 
             * 传入 sink 节点将被作为新创建的 sink 节点的下游节点
             */
            sink = p.opWrapSink(p.previousStage.combinedFlags, sink);
        }
        return (Sink<P_IN>) sink;
    }

    // sign_m_113
    @Override
    final <P_IN> boolean copyIntoWithCancel(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator) {
        @SuppressWarnings({"rawtypes","unchecked"})
        AbstractPipeline p = AbstractPipeline.this;
        while (p.depth > 0) {
            p = p.previousStage; // 找出首节点
        }

        wrappedSink.begin(spliterator.getExactSizeIfKnown()); // sink 开始，传入集合大小 size
        boolean cancelled = p.forEachWithCancel(spliterator, wrappedSink); // for 循环处理  sign_m_120
        wrappedSink.end(); // sink 结束
        return cancelled;
    }

• java.util.stream.ReferencePipeline

    // sign_m_120
    @Override
    final boolean forEachWithCancel(Spliterator<P_OUT> spliterator, Sink<P_OUT> sink) {
        boolean cancelled;
        do { } while (!(cancelled = sink.cancellationRequested()) && spliterator.tryAdvance(sink)); // sign_m_130
        return cancelled;
    }

• java.util.Spliterators.IteratorSpliterator
  • sign_m_011

        // sign_m_130 让 sink 消费每一个元素
        @Override
        public boolean tryAdvance(Consumer<? super T> action) {
            if (action == null) throw new NullPointerException();
            if (it == null) {
                it = collection.iterator();
                est = (long) collection.size();
            }
            if (it.hasNext()) {
                action.accept(it.next()); // sink 消费
                return true;
            }
            return false;
        }

总结

• 排序会创建临时集合，用于收集元素
• 流的双向链是为创建 Sink 单向链做准备