浅谈 jdk 中的 Stream 流使用及原理

最新推荐文章于 2024-03-15 01:39:30 发布

头秃的程序员小王

最新推荐文章于 2024-03-15 01:39:30 发布

阅读量2.6k

点赞数 4

分类专栏： Java核心卷一 JAVA核心卷二文章标签： java stream

本文链接：https://blog.csdn.net/qq_39326472/article/details/122334026

版权

Java核心卷一同时被 2 个专栏收录

15 篇文章 2 订阅

订阅专栏

JAVA核心卷二

5 篇文章 1 订阅

订阅专栏

一、操作分类

Stream 流的出现主要是为了简化迭代的操作，提高迭代效率。

简单解释一下表格中加粗字体的含义：

中间操作：从字面上看是流从开始到结束中间的一环，从操作结果上看是上一个流经过中间操作生成了下一个流，从代码上看实际上是生成了一个个 stage 和 sink节点，至于 sink 节点是什么，后面的篇幅会分析
结束操作：和中间操作相反，结束操作之后是流的最后一个环节，不再生成新的流，从代码上看是启动整个 sink 节点从头开始运行
有状态：简单理解就是需要获取流中所有数据之后才能进行的操作，比如 sort 排序，肯定要获取了所有的元素之后才能排序
无状态：不需要获取所有元素，只需要对单个元素进行的操作，比如 filter 过滤，只针对每一个元素本身所做的操作
短路：终结操作中只要有一个元素可以得到操作结果的数据，比如 findAnyMatch，只要有一个节点满足筛选条件就会返回 true
非短路：需要遍历所有的节点才能得到预期结果，比如 forEach、max

二、Stream流原理探究

2.1 重要的接口类

BaseStream

最顶端的接口类，定义了流的基本接口方法，最主要的方法为 spliterator、isParallel。

Stream

最顶端的接口类。定义了流的常用方法，例如 map、filter、sorted、limit、skip、collect 等。

ReferencePipeline

ReferencePipeline 是一个结构类，定义内部类组装了各种操作流，定义了Head、StatelessOp、StatefulOp三个内部类，实现了 BaseStream 与 Stream 的接口方法。

Sink

Sink 接口定义了 Stream 之间的操作行为，包含 begin()、end()、cancellationRequested()、accpt()四个方法。ReferencePipeline最终会将整个 Stream 流操作组装成一个调用链，而这条调用链上的各个 Stream 操作的上下关系就是通过 Sink 接口协议来定义实现的。

2.2 类图

首先看一下类的继承关系图：

源码中，以 Stage 来描述每个阶段，而且是典型的双向链表结构。因此 Stream 流过程可以用下图描述

流程图

2.3 实例分析

list.stream().filter(integer -> integer>5).sorted().max();

2.3.1 生成 Head 对象

第一步是 stream 方法，最终调用到下面的代码，可以看出，调用完 stream 方法后本质上生成了一个 Head 对象

public final class StreamSupport {
    public static <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel) {
        Objects.requireNonNull(spliterator);
        //生成 Head
        return new ReferencePipeline.Head<>(spliterator,                                        StreamOpFlag.fromCharacteristics(spliterator),
                                            parallel);
    }
}
abstract class AbstractPipeline<E_IN, E_OUT, S extends BaseStream<E_OUT, S>>
       extends PipelineHelper<E_OUT> implements BaseStream<E_OUT, S> {
    AbstractPipeline(Spliterator<?> source,
                 int sourceFlags, boolean parallel) {
    // 上游 Stage，Head 上游为 null
    this.previousStage = null;
    // 源分裂器，可以理解成高级版本的迭代器
    this.sourceSpliterator = source;
    // Head 指针，指向自己
    this.sourceStage = this;
    //是否是中间操作的标志
    this.sourceOrOpFlags = sourceFlags & StreamOpFlag.STREAM_MASK;
    // The following is an optimization of:
    //源以及所有操作的组合源的操作标志，包括此管道对象表示的操作。在评估管道准备时有效。
    this.combinedFlags = (~(sourceOrOpFlags << 1)) & StreamOpFlag.INITIAL_OPS_VALUE;
    //此管道对象与流源（如果是顺序）之间的中间操作数，Head 的 depth 为 0
    this.depth = 0;
    //如果管道是并行的，则为真，否则管道是顺序的;仅对源阶段有效.
    this.parallel = parallel;
    }
}

2.3.2. 生成 filter 对应的操作对象

第二步是 filter 方法，最终调用如下，创建了一个无状态的操作对象 StatelessOp，创建对象时会将 Head (this) 对象传入，构建双向链表关系，同时也会记录 sourceStage (Head) 。至此，上图的指向关系已经明了。

@Override
public final Stream<P_OUT> filter(Predicate<? super P_OUT> predicate) {
    Objects.requireNonNull(predicate);
    //这里的 this 是 Head 对象 ，最终会被当前 StatelessOp 对象作为 previousStage 记录，同时也会将 Head 对象的 nextStage 指向 StatelessOp
    return new StatelessOp<P_OUT, P_OUT>(this, StreamShape.REFERENCE,
                                         StreamOpFlag.NOT_SIZED) {
        @Override
        Sink<P_OUT> opWrapSink(int flags, Sink<P_OUT> sink) {
            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);
                }
            };
        }
    };
}
AbstractPipeline(AbstractPipeline<?, E_IN, ?> previousStage, int opFlags) {
    if (previousStage.linkedOrConsumed)
        throw new IllegalStateException(MSG_STREAM_LINKED);
    previousStage.linkedOrConsumed = true;
    //将 Head 的 nextStage 指针指向当前对象，即封装了 filter 的 StatelessOp 对象
    previousStage.nextStage = this;
    //将 StatelessOp 对象的 previousStage 指向 Head
    this.previousStage = previousStage;
    this.sourceOrOpFlags = opFlags & StreamOpFlag.OP_MASK;
    this.combinedFlags = StreamOpFlag.combineOpFlags(opFlags, previousStage.combinedFlags);
    //将 StatelessOp 对象的 sourceStage 指向 Head
    this.sourceStage = previousStage.sourceStage;
    if (opIsStateful())
        sourceStage.sourceAnyStateful = true;
    this.depth = previousStage.depth + 1;
}

这里出现了 Sink 接口和 Sink 接口的实现类 ChainedReference ，Sink 接口是用来联系当前流和下一个流的协议接口，每个 AbstractPipeline 的具体子类都要实现 opWrapSink 方法返回一个 Sink 实例。

interface Sink<T> extends Consumer<T> {
    //开始方法，可以通知下游做些相关准备
    default void begin(long size) {}
    //结束方法，告诉下游已经完成所有元素的迭代操作
    default void end() {}
    //是否是短路操作
    default boolean cancellationRequested() {
        return false;
    }
    //Sink 接口的默认实现类
    static abstract class ChainedReference<T, E_OUT> implements Sink<T> {
        //此处的 downstream 意指下游的处理 sink
        protected final Sink<? super E_OUT> downstream;
        public ChainedReference(Sink<? super E_OUT> downstream) {
            this.downstream = Objects.requireNonNull(downstream);
        }
        @Override
        //默认直接调用下游的 begin 方法
        public void begin(long size) {
            downstream.begin(size);
        }
        @Override
        //默认直接调用下游的 end 方法
        public void end() {
            downstream.end();
        }
        @Override
        //返回是否短路
        public boolean cancellationRequested() {
            return downstream.cancellationRequested();
        }
    }
}

2.3.3. 生成 sorted 对应的对象

第三步的 sorted 方法，sorted 返回的是 OfRef 类的一个实例，类似 filter ，同样也实现了 opWrapSink 方法，不过因为 sorted 方法实现的是排序功能，所以这里会确定比较器 comparator，最后由比较器实现排序逻辑。


private static final class OfRef<T> extends ReferencePipeline.StatefulOp<T, T> {
    OfRef(AbstractPipeline<?, T, ?> upstream) {
        //类似 filter 方法，确定上下游 stage 关系
        super(upstream, StreamShape.REFERENCE,
              StreamOpFlag.IS_ORDERED | StreamOpFlag.IS_SORTED);
        this.isNaturalSort = true;
        @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
            //返回的是 RefSortingSink 实例
            return new RefSortingSink<>(sink, comparator);
    }
}
 private static final class RefSortingSink<T> extends AbstractRefSortingSink<T> {
        private ArrayList<T> list;
        RefSortingSink(Sink<? super T> sink, Comparator<? super T> comparator) {
            super(sink, comparator);
        }
        @Override
         //开始操作，初始化一个 list，用于接收上游流过来的元素，进行排序
        public void begin(long size) {
            if (size >= Nodes.MAX_ARRAY_SIZE)
                throw new IllegalArgumentException(Nodes.BAD_SIZE);
            list = (size >= 0) ? new ArrayList<T>((int) size) : new ArrayList<T>();
        }
        @Override
         //实际的排序操作
        public void end() {
            list.sort(comparator);
            downstream.begin(list.size());
            //终结操作不是短路操作，遍历
            if (!cancellationWasRequested) {
                list.forEach(downstream::accept);
            }
            //终结操作是短路操作，找到满足的元素
            else {
                for (T t : list) {
                    if (downstream.cancellationRequested()) break;
                    downstream.accept(t);
                }
            }
            //结束
            downstream.end();
            list = null;
        }
        @Override
         //添加元素到初始化好的 list 中
        public void accept(T t) {
            list.add(t);
        }
    }

2.3.4. 拨动齿轮

至此为止，我们已经构建好了双向链表的操作，每个操作都被保存到一个个 StatelessOp 或者 StatefulOp 对象中，但在之前的操作中，我们封装好的 Sink 对象并没有实际调用，这也是为什么 Stream 流如果不进行终结操作之前的中间操作都不会触发的原因，万事俱备，只欠东风。东风就是终结操作。最后为 max(Comparator.naturalOrder())，是终结操作，会生成一个最终的 Stage，通过这个 Stage 触发之前的中间操作，从最后一个Stage开始，递归产生一个Sink链。

1）java.util.stream.ReferencePipeline#max

@Override
public final Optional<P_OUT> max(Comparator<? super P_OUT> comparator) {
    return reduce(BinaryOperator.maxBy(comparator));
}

2）最终调用到 java.util.stream.AbstractPipeline#wrapSink，这个方法会调用 opWrapSink 生成一个 Sink 链表，对应到本文的例子，就是 filter 和 map 操作。

@Override
@SuppressWarnings("unchecked")
final <P_IN> Sink<P_IN> wrapSink(Sink<E_OUT> sink) {
    Objects.requireNonNull(sink);
    for ( @SuppressWarnings("rawtypes") AbstractPipeline p=AbstractPipeline.this; p.depth > 0; p=p.previousStage) {
        sink = p.opWrapSink(p.previousStage.combinedFlags, sink);
    }
    return (Sink<P_IN>) sink;
}

3）wrapAndCopyInto 生成 Sink 链表后，会通过 copyInfo 方法执行 Sink 链表的具体操作。


@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);
    }
}

4）java.util.Spliterators.ArraySpliterator#forEachRemaining

@Override
public void forEachRemaining(Consumer<? super T> action) {
    Object[] a; int i, hi; // hoist accesses and checks from loop
    if (action == null)
        throw new NullPointerException();
    if ((a = array).length >= (hi = fence) &&
        (i = index) >= 0 && i < (index = hi)) {
        do { action.accept((T)a[i]); } while (++i < hi);
    }
}

三、用面向对象的思维去理解 Stream 流

类比实际生活，我们可以将 Stream 流比作水流，中间操作则是相当于水流过程中的蓄水池，Sink则是每个蓄水池的操作者，终结操作则是下达指令的指挥官。此例中的操作可如下图：

四、Stream流中的责任链模式

顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

sink的链表从头开始处理元素，处理完交给后面的sink结点继续处理。直到尾结点，使用了责任链模式

五、Stream流中使用的匿名内部类

Stream在创建中间处理结点时创建了Sink.ChainedReference抽象类的匿名内部类。匿名内部类的内部使用了外部变量predicate。匿名内部类在使用外部变量时，会自动生成构造函数，并使用该外部变量生成同类型的匿名内部类的成员变量。因此每次调用filter操作，实际上是调用opWrapSink操作，如果调用filter时使用函数a)生成predicate,其实该函数a不是在每个元素经过调用链时被调用，而是只有在调用链被初始化时调用一次。之后的每次filter都是使用匿名内部类的成员变量进行过滤。

@Override
public final Stream<P_OUT> filter(Predicate<? super P_OUT> predicate) {
    Objects.requireNonNull(predicate);
    //这里的 this 是 Head 对象 ，最终会被当前 StatelessOp 对象作为 previousStage 记录，同时也会将 Head 对象的 nextStage 指向 StatelessOp
    return new StatelessOp<P_OUT, P_OUT>(this, StreamShape.REFERENCE,
                                         StreamOpFlag.NOT_SIZED) {
        @Override
        Sink<P_OUT> opWrapSink(int flags, Sink<P_OUT> sink) {
            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);
                }
            };
        }
    };
}

参考：

Java Stream 源码分析

浅谈 jdk 中的 Stream 流使用及原理