Java8 Stream源码精讲(一):从一个简单的例子入手

简介

Java8引入Stream这个新特性之后,通过使用lambda表达式增强集合的功能,使程序员通过声明式的方式,快速和便捷的对批量数据进行过滤、转换、分组规约等操作,同时提高编程效率和代码可读性,可以说是一个真正的开发利器。本章我通过一个简单的示例,带领大家理解Stream的内部原理。

继承体系

在进入示例之前,我们先来看一下Stream的类继承结构。

微信图片_20220523143534.png 图中展示的是ReferencePipeline的继承关系,Stream和ReferencePipeline都是针对引用类型定义的接口和类,还有针对int、long、double基础类型的流IntStream、LongStream、DoubleStream、IntPipeline、LongPipeline和DoublePipeline。本章只打算讲解引用类型的流,也就是大家常用的Stream,后面会有专门的章节来讲解基础类型的流,下面大致说明一下各个类和接口的职责功能。

  • BaseStream: 所有Stream都继承自这个接口,主要声明了并行流和串行流的转换,判断流类型等方法。
  • Stream: 继承BaseStream接口,提供了所有引用类型的中间操作和终止操作方法,什么是中间操作和终止操作,后面会详细讲解。
  • PipelineHelper: 流管道的帮助类,定义了管道的基础方法,由AbstractPipeline实现。
  • AbstractPipeline: 流管道基础类,继承PipelineHelper并且实现了继承BaseStream接口接口,所有的流都继承这个类,内部通过双向链表的结构来维护管道之间的关系。
  • ReferencePipeline: 引用类型的管道类,继承了AbstractPipeline,连接管道的能力。同时实现了Stream接口,所以具备相应的流操作功能。
  • Head: ReferencePipeline的内部类,同时也继承自ReferencePipeline,构建的Stream对象其实就是这个类的实例。
  • StatelessOp: 同样是ReferencePipeline的内部类,并且继承了ReferencePipeline,调用流的无状态操作方法会返回这个类的子类实例。
  • StatefulOp: 同上,不过表示有状态操作。

下面我们来看看顶层接口和类的方法和字段声明,本章只粗略的讲解BaseStream、PipelineHelper和AbstractPipeline,其它的留到后面的章节详细讲解。

BaseStream

//返回流代表集合的迭代器
Iterator<T> iterator();

//返回流元素的Spliterator,什么是Spliterator,翻译成中文是分离器,
//目前大家只需要知道这是一个类似迭代器的东西,主要用于终止操作的时候遍历元素
Spliterator<T> spliterator();

//返回流是不是并行的
boolean isParallel();

//返回串行流
S sequential();

//返回并行流
S parallel();
复制代码

PipelineHelper

//返回流类型,有REFERENCE、INT_VALUE、LONG_VALUE、DOUBLE_VALUE类型
abstract StreamShape getSourceShape();

//返回流合并和操作的标志,这个过于复杂,不打算深讲
abstract int getStreamAndOpFlags();

//返回流元素大小,如果不确定将返回-1
abstract<P_IN> long exactOutputSizeIfKnown(Spliterator<P_IN> spliterator);

//由终止操作间接调用,调用wrapSink方法构建Sink链表,调用copyInto方法完成数据操作
abstract<P_IN, S extends Sink<P_OUT>> S wrapAndCopyInto(S sink, Spliterator<P_IN> spliterator);

//将Spliterator中的元素提供给Sink消费
abstract<P_IN> void copyInto(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator);

//类似copyInto,区别在于这个方法用于短路操作
abstract <P_IN> void copyIntoWithCancel(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator);

//包装Sink形成Sink链
abstract<P_IN> Sink<P_IN> wrapSink(Sink<P_OUT> sink);

abstract<P_IN> Spliterator<P_OUT> wrapSpliterator(Spliterator<P_IN> spliterator);

abstract Node.Builder<P_OUT> makeNodeBuilder(long exactSizeIfKnown,
                                             IntFunction<P_OUT[]> generator);

//并行流调用,本系列文章不涉及
abstract<P_IN> Node<P_OUT> evaluate(Spliterator<P_IN> spliterator,
                                    boolean flatten,
                                    IntFunction<P_OUT[]> generator);
复制代码

AbstractPipeline

//pipeline链表的头结点
private final AbstractPipeline sourceStage;

//前一个节点
private final AbstractPipeline previousStage;

protected final int sourceOrOpFlags;

//下一个节点
private AbstractPipeline nextStage;

//节点的深度
private int depth;

private int combinedFlags;

//源Spliterator
private Spliterator<?> sourceSpliterator;

//同sourceSpliterator
private Supplier<? extends Spliterator<?>> sourceSupplier;

//pipeline是否已经被连接或者消费
private boolean linkedOrConsumed;

//pipeline上是否有有状态的操作
private boolean sourceAnyStateful;

private Runnable sourceCloseAction;

//是否是并行流
private boolean parallel;
复制代码
  • sourceStage:pipeline链表的头结点,如果当前节点就是头节点,那么将指向自己。
  • previousStage:链表的上一个节点。
  • nextStage:链表的下一个节点。
  • depth:节点的深度,头结点深度为0,后续每调用一个中间操作,返回的Stream节点深度加1。
  • sourceSpliterator:源Spliterator。
  • sourceSupplier:同sourceSpliterator。
  • linkedOrConsumed:pipeline是否已经被连接或者消费,如果为true,再调用操作方法将抛出IllegalStateException异常。
  • sourceAnyStateful:pipeline上是否有有状态的操作,如果有调用有状态中间操作,那么头结点的sourceAnyStateful会被设置为true。

一个简单的示例

我们先来看一个使用Stream的例子

Stream.of("java", "scala", "go", "python")
        .map(String::length)
        .filter(len -> len <= 4)
        .forEach(System.out::println);
复制代码

很显然,例子中的运行结果是在控制台输出4和2:

4
2
复制代码

上面的代码中通过Stream#of()方法创建一个源Stream实例,然后依次调用map()、filter()中间操作方法,最终调用forEach()终止操作方法得到最终的结果。其中中间操作不会立即执行声明的逻辑,只有调用终止操作之后才触发所有的逻辑。

Stream的构建

我们先来看一下这个例子中Stream是如何构建的,方法Stream#of():

public static<T> Stream<T> of(T... values) {
  return Arrays.stream(values);
}
复制代码

Stream#of()是一个工厂方法,会调用到Arrays#stream():

public static <T> Stream<T> stream(T[] array) {
  return stream(array, 0, array.length);
}
复制代码

然后调用重载方法

public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive) {
  return StreamSupport.stream(spliterator(array, startInclusive, endExclusive), false);
}
复制代码

构建一个Spliterator,目前我们只要知道它是一个类似迭代器一样的东西就行了,后面会详细讲解,所以还是看StreamSupport#stream()方法:

public static <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel) {
  Objects.requireNonNull(spliterator);
  return new ReferencePipeline.Head<>(spliterator,
                                      StreamOpFlag.fromCharacteristics(spliterator),
                                      parallel);
}
复制代码

构建一个Head实例,Head就是上面讲到的ReferencePipeline的子类,我们看一下它的构造方法:

Head(Spliterator<?> source,
   int sourceFlags, boolean parallel) {
  super(source, sourceFlags, parallel);
}
复制代码

调用父构造器:

ReferencePipeline(Spliterator<?> source,
                int sourceFlags, boolean parallel) {
  super(source, sourceFlags, parallel);
}
复制代码

最终调用到AbstractPipeline的构造方法:

AbstractPipeline(Spliterator<?> source,
               int sourceFlags, boolean parallel) {
  //由于是头结点,所以上一个节点为null
  this.previousStage = null;
  //源Spliterator
  this.sourceSpliterator = source;
  //由于是头结点,所以sourceStage指向自己
  this.sourceStage = this;
  //涉及流合并和操作标记,过于复杂,暂时不讲解
  this.sourceOrOpFlags = sourceFlags & StreamOpFlag.STREAM_MASK;
  // The following is an optimization of:
  // StreamOpFlag.combineOpFlags(sourceOrOpFlags, StreamOpFlag.INITIAL_OPS_VALUE);
  this.combinedFlags = (~(sourceOrOpFlags << 1)) & StreamOpFlag.INITIAL_OPS_VALUE;
  //头结点的深度是0
  this.depth = 0;
  //并行流标记
  this.parallel = parallel;
}
复制代码

所有说明都在源码上面注释了,从上面源码可以得出结论,构建Stream返回的是一个ReferencePipeline.Head实例,它的结构如下:

9UJLP8(S6P)OT$V{P%B)(CQ.png

中间操作

map()方法

接下来我们看一下map()方法调用逻辑,首先会调用ReferencePipeline#map():

public final <R> Stream<R> map(Function<? super P_OUT, ? extends R> mapper) {
    Objects.requireNonNull(mapper);
    //返回一个StatelessOp子类实例,传入Head实例
    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));
                }
            };
        }
    };
}
复制代码

我们发现这里创建了一个StatelessOp的子类实例,StatelessOp也就是上面讲到的ReferencePipeline的内部类和子类,它是一个无状态的中间操作,构造方法如下:

StatelessOp(AbstractPipeline<?, E_IN, ?> upstream,
            StreamShape inputShape,
            int opFlags) {
    super(upstream, opFlags);
    assert upstream.getOutputShape() == inputShape;
}
复制代码

还是调用ReferencePipeline的构造方法:

ReferencePipeline(AbstractPipeline<?, P_IN, ?> upstream, int opFlags) {
    super(upstream, opFlags);
}
复制代码

最终还是调用到AbstractPipeline的构造方法:

AbstractPipeline(AbstractPipeline<?, E_IN, ?> previousStage, int opFlags) {
    //这里也解释了Stream只能被连接或者消费一次,否则会抛出异常
    if (previousStage.linkedOrConsumed)
        throw new IllegalStateException(MSG_STREAM_LINKED);
    previousStage.linkedOrConsumed = true;
    //构建双向链表,将上一个节点也就是Head的nextStage指向自己
    previousStage.nextStage = this;
    //将当前节点的previousStage指向上一个节点,也就是Head对象
    this.previousStage = previousStage;
    this.sourceOrOpFlags = opFlags & StreamOpFlag.OP_MASK;
    this.combinedFlags = StreamOpFlag.combineOpFlags(opFlags, previousStage.combinedFlags);
    //将当前节点的sourceStage指向上一个节点的sourceStage,也就是Head对象
    this.sourceStage = previousStage.sourceStage;
    //如果当前操作是有状态的,那么sourceStage也就是Head对象sourceAnyStateful设置为true,这里是无状态的,跳过
    if (opIsStateful())
        sourceStage.sourceAnyStateful = true;
    //深度加1
    this.depth = previousStage.depth + 1;
}
复制代码

注意构造参数,这个明显不是构建Stream的时候调用的构造器,上面传入的previousStage就是构建Stream时返回的Head对象。

所以经过Stream.of("java", "scala", "go", "python").map(String::length)调用之后,返回的是ReferencePipeline.StatelessOp的子类实例,结构变化如下:

UIVX8BVB%``GPTZU%LAJPSL.png

filter()方法

filter()方法首先会调用到ReferencePipeline#filter()方法:

public final Stream<P_OUT> filter(Predicate<? super P_OUT> predicate) {
    Objects.requireNonNull(predicate);
    ////返回一个StatelessOp子类实例,注意与上面对比,这里传入的是map()方法体里面的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);
                }
            };
        }
    };
}
复制代码

与ReferencePipeline#map()方法一样,最终也会返回一个StatelessOp子类实例,结构变化如下:

(DEL2LGF)U$QIK}B{`(13@K.png

终止操作

示例中最后调用的是Stream#forEach()方法,forEach()是一个终止操作,会触发上面声明的逻辑真正执行,这里会调用到ReferencePipeline#forEach()方法:

public void forEach(Consumer<? super P_OUT> action) {
    evaluate(ForEachOps.makeRef(action, false));
}
复制代码

ForEachOps#makeRef()是一个工厂方法,会返回一个TerminalOp实例,它代表的就是终止操作,这里返回的是ForEachOp.OfRef:

public static <T> TerminalOp<T, Void> makeRef(Consumer<? super T> action,
                                              boolean ordered) {
    Objects.requireNonNull(action);
    return new ForEachOp.OfRef<>(action, ordered);
}
复制代码

我们先来看一下OfRef:

static final class OfRef<T> extends ForEachOp<T> {
    final Consumer<? super T> consumer;
    //这里传入的consumer就是forEach()传入的lambda
    OfRef(Consumer<? super T> consumer, boolean ordered) {
        super(ordered);
        this.consumer = consumer;
    }

    //在这个方法中真正的调用lambda
    @Override
    public void accept(T t) {
        consumer.accept(t);
    }
}
复制代码

OfRef继承自ForEachOp,那我们来看一下它的定义:

static abstract class ForEachOp<T>
        implements TerminalOp<T, Void>, TerminalSink<T, Void> {
        ....
        }
复制代码

ForEachOp实现了TerminalOp和TerminalSink接口,TerminalOp主要提供了evaluateParallel()和evaluateSequential()方法:

//并行流调用的方法,我们不关注
default <P_IN> R evaluateParallel(PipelineHelper<E_IN> helper,
                                  Spliterator<P_IN> spliterator) {
    if (Tripwire.ENABLED)
        Tripwire.trip(getClass(), "{0} triggering TerminalOp.evaluateParallel serial default");
    return evaluateSequential(helper, spliterator);
}

//这个方法在Stream终止操作当中会调用到,主要作用是封装sink链,执行数据处理逻辑,非常重要,后面会讲到
<P_IN> R evaluateSequential(PipelineHelper<E_IN> helper,
                            Spliterator<P_IN> spliterator);
复制代码

ForEachOp实现的另外一个接口是TerminalSink,它的接口声明如下:

interface TerminalSink<T, R> extends Sink<T>, Supplier<R> { }
复制代码

可以看到它聚合了Sink和Supplier接口,Supplier就是一个函数式接口,只有一个get()方法,我们来看一下Sink的定义:

interface Sink<T> extends Consumer<T> {
    
    //发送数据到sink之前调用的方法
    default void begin(long size) {}

    //在所有数据被发送到sink后调用的方法
    default void end() {}

    //用于判断是否短路
    default boolean cancellationRequested() {
        return false;
    }
}
复制代码

Sink继承了Consumer接口,拥有accept()方法。我们来看一下它的每一个方法是干什么的:

  • begin():这个方法在发送数据到sink之前被调用,通常用于状态的清理和重置。对于无状态操作,一般只会向下游的sink传播;对于有状态的操作,还会初始化sink的一些内部变量。后面针对每一个sink实现类,我们会详细分析。
  • accept():这个方法继承自Consumer,每一个元素被发送到sink,都会调用到这个方法。
  • end():在流上的数据被sink处理完成之后,会调用这个方法。对于无状态操作,一般除了向下游传播,不会做其它操作;对于有状态的操作,会做一些清理或者更复杂的工作。
  • cancellationRequested():这个方法用于判断是否可以提前结束,也就是我们所说的是否短路。 终止操作forEach()里面,返回了ForEachOp.OfRef实例之后就会调用evaluate()方法:
public void forEach(Consumer<? super P_OUT> action) {
    evaluate(ForEachOps.makeRef(action, false));
}
复制代码

这个方法在AbstractPipeline里面实现:

final <R> R evaluate(TerminalOp<E_OUT, R> terminalOp) {
    assert getOutputShape() == terminalOp.inputShape();
    //校验Stream是否已经被消费过,更改状态
    if (linkedOrConsumed)
        throw new IllegalStateException(MSG_STREAM_LINKED);
    linkedOrConsumed = true;

    return isParallel()
           ? terminalOp.evaluateParallel(this, sourceSpliterator(terminalOp.getOpFlags()))
           //示例中是串行流,所以只关心这个方法
           : terminalOp.evaluateSequential(this, sourceSpliterator(terminalOp.getOpFlags()));
}
复制代码

evaluate()做了linkedOrConsumed的状态校验,最终调用TerminalOp#evaluateSequential()方法,传入的参数是PipelineHelper和Spliterator。在本例中PipelineHelper就是Stream#filter()方法中的StatelessOp子类实例,忘记了的记得倒回去看哟。至于sourceSpliterator()返回的是什么Spliterator,我们进入这个方法看一下:

private Spliterator<?> sourceSpliterator(int terminalFlags) {
    // Get the source spliterator of the pipeline
    Spliterator<?> spliterator = null;
    //实际走的是这个逻辑
    if (sourceStage.sourceSpliterator != null) {
        spliterator = sourceStage.sourceSpliterator;
        sourceStage.sourceSpliterator = null;
    }
    else if (sourceStage.sourceSupplier != null) {
        spliterator = (Spliterator<?>) sourceStage.sourceSupplier.get();
        sourceStage.sourceSupplier = null;
    }
    else {
        throw new IllegalStateException(MSG_CONSUMED);
    }

    //并行流的逻辑
    if (isParallel() && sourceStage.sourceAnyStateful) {
        ...
    }

    if (terminalFlags != 0)  {
        // Apply flags from the terminal operation to last pipeline stage
        combinedFlags = StreamOpFlag.combineOpFlags(terminalFlags, combinedFlags);
    }

    return spliterator;
}
复制代码

这个方法比较长,省略了无关代码,基本上都是并行流处理和返回新的Spliterator,串行流只会返回Head的sourceSpliterator。evaluate()最终调用的是ForEachOp.OfRef#evaluateSequential(),这个方法在ForEach中实现:

public <S> Void evaluateSequential(PipelineHelper<T> helper,
                                   Spliterator<S> spliterator) {
    return helper.wrapAndCopyInto(this, spliterator).get();
}
复制代码

调用StatelessOp的wrapAndCopyInto()方法,传入ForEachOp.OfRef实例和spliterator,进入wrapAndCopyInto()看一下,AbstractPipeline#wrapAndCopyInto():

final <P_IN, S extends Sink<E_OUT>> S wrapAndCopyInto(S sink, Spliterator<P_IN> spliterator) {
    copyInto(wrapSink(Objects.requireNonNull(sink)), spliterator);
    return sink;
}
复制代码

首先调用AbstractPipeline#wrapSink()返回一个新的sink:

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;
}
复制代码

这个方法的逻辑就是从Pipeline双向链表从后向前遍历直到Head,依次调用opWrapSink()方法包装一个新的Sink。我们来分析一下在本示例中构造的是一个什么样的sink:

  • 首先,调用Stream.filter()方法中StatelessOp实例的opWrapSink()方法,传入的sink是代表终止操作的ForEachOp.OfRef实例:
public final Stream<P_OUT> filter(Predicate<? super P_OUT> predicate) {
    Objects.requireNonNull(predicate);
    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);
                }
            };
        }
    };
}
复制代码

我再次把代码放出来了,可以看到opWrapSink()返回的是一个Sink.ChainedReference实例,Sink.ChainedReference又是什么鬼?我们进入看一下:

static abstract 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);
    }

    @Override
    public void begin(long size) {
        downstream.begin(size);
    }

    @Override
    public void end() {
        downstream.end();
    }

    @Override
    public boolean cancellationRequested() {
        return downstream.cancellationRequested();
    }
}
复制代码

ChainedReference实现了Sink接口,通过变量downstream形成一个连接下游sink的单链表,它实现的begin()、end()、cancellationRequested()方法都是向下游传播。所以在Pipeline链表上第一次迭代形成的sink链表结构如下:

}O`0ZU2R$WG38@72BVHPAS.png

  • 我们再回到迭代逻辑:
for ( @SuppressWarnings("rawtypes") AbstractPipeline p=AbstractPipeline.this; p.depth > 0; p=p.previousStage) {
        sink = p.opWrapSink(p.previousStage.combinedFlags, sink);
    }
复制代码

第二次调用的是Stream.map()方法中StatelessOp实例的opWrapSink()方法,传入的sink是filter方法中的Sink.ChainedReference实例:

public final <R> Stream<R> map(Function<? super P_OUT, ? extends R> mapper) {
    Objects.requireNonNull(mapper);
    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));
                }
            };
        }
    };
}
复制代码

可以看到逻辑跟filter方法中的基本一致,都是返回一个Sink.ChainedReference子类实例,主要区别是accept()中的逻辑。所以经过第二次迭代形成的sink链表如下:

N%)SR%735G7)X0}EY0UEDBU.png 到这里sink链表就构造完成了,最终返回:

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;
}
复制代码

可以看到for循环中的条件是p.depth > 0,并且Head#opWrapSink()会抛出UnsupportedOperationException异常,所以Head的opWrapSink()方法不会被调用。

final Sink<E_IN> opWrapSink(int flags, Sink<E_OUT> sink) {
    throw new UnsupportedOperationException();
}
复制代码

通过wrapSink()方法构造sink链表之后,会调用AbstractPipeline#copyInto()方法执行真正的数据处理逻辑:

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);
    }
}
复制代码

由于Stream#forEach()是非短路操作,所以进入的是上面的逻辑,通过调试也能够看出: 76NW243QE{AF_{5OB}66RUE.png 同时可以看到传入的sink就是上面分析的sink链表:

VKXQ9G8E7}VKV~B25W$XV_T.png 这里的逻辑分为三步,我们分开来讲解:

//1.调用sink链的begin()方法
wrappedSink.begin(spliterator.getExactSizeIfKnown());
//2.调用spliterator的forEachRemaining()方法
spliterator.forEachRemaining(wrappedSink);
//3.调用sink链的end()方法
wrappedSink.end();
复制代码
  1. 第一步:调用sink链的begin()方法,传入元素大小,这里通过spliterator#getExactSizeIfKnown()获取到,本例中是4,只是沿着sink链向下游传播,不做其它操作。
  2. 第二步:调用方法ArraySpliterator#forEachRemaining(),传入sink链,可以看到就是循环调用sink#accept()方法,传入数组元素:
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);
    }
}
复制代码

经过sink链的流程如下:

return new Sink.ChainedReference<P_OUT, R>(sink) {
    @Override
    public void accept(P_OUT u) {
        downstream.accept(mapper.apply(u));
    }
};
复制代码

sink链头结点是Stream#map()方法里面的Sink.ChainedReference,元素经过函数String::length转换,然后传递给下一个sink:

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);
            }
        };
    }
};
复制代码

第二个sink节点是Stream#filter()方法中的Sink.ChainedReference,这里元素要经过函数len -> len <= 4判断返回true,才会传递到下一个节点:

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

    OfRef(Consumer<? super T> consumer, boolean ordered) {
        super(ordered);
        this.consumer = consumer;
    }

    @Override
    public void accept(T t) {
        consumer.accept(t);
    }
}
复制代码

最后一个节点是ForEachOp.OfRef,它的逻辑就是将前一个sink节点传递过来的元素都通过System.out::println打印到控制台。

  1. 第三步:调用sink链的end()方法,在这个例子中从sink头节点依次调用下一个节点的end()方法,什么都不做。

到这里使用Stream处理数据的流程和源码就分析完了。

总结

本文先通过介绍Stream的继承结构,以及分析顶层的接口和抽象类中的方法和字段,让大家对Stream这个家族有一个总体的认识。然后通过一个简单的例子,详细的讲解了Steam是怎么构建的,经过中间操作如何形成一个Pipeline链表,终止操作是如何将声明的函数构建为一个sink链表,Stream中的元素如何经过sink处理的。

写在最后

关于Java8中的Stream源码还有很多可以讲解的地方,比如有哪些方式创建Stream,中间操作是什么,有几种终止操作,Collector为什么有强大的分组规约能力,IntStream、LongStream、DoubleStream和普通Stream的关系。所以我打算写一系列文章、以专栏的形式,来详细讲解Stream相关的源码。

  • 关于并行流,其中涉及到ForkJoinPool线程池、分治算法等更复杂的知识,将这些写进来会导致篇幅过大、不易阅读,所以本系列不打算讲解,大家略过就好,不会影响阅读。
  • 关于StreamOpFlag,同理过于复杂,一来不易讲解,二来容易把大家绕晕,所以也不讲解。

最后,原创不易,如果觉得本系列文章对您有帮助,能够加深您对Stream原理和源码的理解的话,请不要吝啬您手中的赞(✪ω✪)!

来源:https://juejin.cn/post/7100824118831874078
posted @ 2022-07-13 23:26  程序员小明1024  阅读(222)  评论(0编辑  收藏  举报