java8新特性-引用流ReferencePipeline

ReferencePipeline实现了Stream接口，Stream接口定义了顺序和并行聚合的元素序列操作。

public interface Stream<T> extends BaseStream<T, Stream<T>> {

   
    Stream<T> filter(Predicate<? super T> predicate);

    
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);

    
    IntStream mapToInt(ToIntFunction<? super T> mapper);

    
    LongStream mapToLong(ToLongFunction<? super T> mapper);

   
    DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);

    
    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

    
    IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);

    
    LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);

   
    DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);

   
    Stream<T> distinct();

    
    Stream<T> sorted();

   
    Stream<T> sorted(Comparator<? super T> comparator);

    
    Stream<T> peek(Consumer<? super T> action);

    
    Stream<T> limit(long maxSize);

    
     
    Stream<T> skip(long n);

    
    void forEach(Consumer<? super T> action);

    
    void forEachOrdered(Consumer<? super T> action);

    
    Object[] toArray();

    
    <A> A[] toArray(IntFunction<A[]> generator);

   
    T reduce(T identity, BinaryOperator<T> accumulator);

    
     
    Optional<T> reduce(BinaryOperator<T> accumulator);

    
    <U> U reduce(U identity,
                 BiFunction<U, ? super T, U> accumulator,
                 BinaryOperator<U> combiner);

    
    <R> R collect(Supplier<R> supplier,
                  BiConsumer<R, ? super T> accumulator,
                  BiConsumer<R, R> combiner);

   
    <R, A> R collect(Collector<? super T, A, R> collector);

    
    Optional<T> min(Comparator<? super T> comparator);

    
    Optional<T> max(Comparator<? super T> comparator);

    
    long count();

   
    boolean anyMatch(Predicate<? super T> predicate);

   
    boolean allMatch(Predicate<? super T> predicate);

   
    boolean noneMatch(Predicate<? super T> predicate);

   
    Optional<T> findFirst();

   
    Optional<T> findAny();

    
    public static<T> Builder<T> builder() {
        return new Streams.StreamBuilderImpl<>();
    }

    
    public static<T> Stream<T> empty() {
        return StreamSupport.stream(Spliterators.<T>emptySpliterator(), false);
    }

   
    public static<T> Stream<T> of(T t) {
        return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
    }

    
    @SafeVarargs
    @SuppressWarnings("varargs") // Creating a stream from an array is safe
    public static<T> Stream<T> of(T... values) {
        return Arrays.stream(values);
    }

    
    public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) {
        Objects.requireNonNull(f);
        final Iterator<T> iterator = new Iterator<T>() {
            @SuppressWarnings("unchecked")
            T t = (T) Streams.NONE;

            @Override
            public boolean hasNext() {
                return true;
            }

            @Override
            public T next() {
                return t = (t == Streams.NONE) ? seed : f.apply(t);
            }
        };
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
                iterator,
                Spliterator.ORDERED | Spliterator.IMMUTABLE), false);
    }

   
    public static<T> Stream<T> generate(Supplier<T> s) {
        Objects.requireNonNull(s);
        return StreamSupport.stream(
                new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s), false);
    }

   
    public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
        Objects.requireNonNull(a);
        Objects.requireNonNull(b);

        @SuppressWarnings("unchecked")
        Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>(
                (Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
        Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
        return stream.onClose(Streams.composedClose(a, b));
    }

    
    public interface Builder<T> extends Consumer<T> {

        
        @Override
        void accept(T t);

       
        default Builder<T> add(T t) {
            accept(t);
            return this;
        }

        
        Stream<T> build();

    }
}

函数名	作用
filter(Predicate<? super T> predicate)	返回匹配断言的所有元素的Stream
map(Function<? super T, ? extends R> mapper)	返回执行函数mapper后所有元素的Stream
mapToInt(ToIntFunction<? super T> mapper)	返回执行函数mapper后所有元素的IntStream
mapToLong(ToLongFunction<? super T> mapper)	返回执行函数mapper后所有元素的LongStream
mapToDouble(ToDoubleFunction<? super T> mapper)	返回执行函数mapper后所有元素的DoubleStream
flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)	返回执行函数mapper后所有元素的Stream，返回后的Stream元素类型是Stream或Stream的子类
flatMapToInt(Function<? super T, ? extends IntStream> mapper)	返回执行函数mapper后所有元素的Stream，返回后的Stream元素类型是IntStream或IntStream的子类
flatMapToLong(Function<? super T, ? extends LongStream> mapper)	返回执行函数mapper后所有元素的Stream，返回后的Stream元素类型是LongStream或LongStream的子类
flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper)	返回执行函数mapper后所有元素的Stream，返回后的Stream元素类型是DoubleStream或DoubleStream的子类
distinct()	去重
sorted()	自然排序
sorted(Comparator<? super T> comparator)	按照Comparator排序
peek(Consumer<? super T> action)	对流中每个元素执行 action，执行完后流未关闭
limit(long maxSize)	返回限制maxSize个元素的Stream
skip(long n)	返回跳过n个元素的Stream
forEach(Consumer<? super T> action)	对流中每个元素执行 action，执行完后流关闭
forEachOrdered(Consumer<? super T> action)	按照顺序对流中每个元素执行 action，执行完后流关闭
toArray()	返回Object[]
toArray(IntFunction<A[]> generator)	返回A[]
reduce(T identity, BinaryOperator accumulator)	返回流中每个元素按照accumulator聚合后的结果
reduce(BinaryOperator accumulator)	返回流中每个元素按照accumulator聚合后的结果
reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator combiner)	返回流中每个元素按照accumulator和combiner聚合后的结果
collect(Collector<? super T, A, R> collector)	收集Stream中的元素
min(Comparator<? super T> comparator)	返回comparator比较器比较的最小值
max(Comparator<? super T> comparator)	返回comparator比较器比较的最大值
count()	Stream中元素数量
anyMatch(Predicate<? super T> predicate)	返回Stream中是否有元素匹配断言
allMatch(Predicate<? super T> predicate)	返回Stream中是否所有元素都匹配断言
noneMatch(Predicate<? super T> predicate)	返回Stream中是否所有元素都不匹配断言
findFirst()	返回Stream中第一个元素或者空
findAny()	返回Stream中任意一个元素或者空
empty()	返回一个空的Stream
of(T t)	返回只有一个元素的顺序流
of(T... values)	返回给定元素的顺序流
iterate(final T seed, final UnaryOperator f)	返回种子， f（种子），f（f（种子））。。。等无限元素的流，f是函数操作
generate(Supplier s)	返回由s生成的无限元素顺序流
concat(Stream<? extends T> a, Stream<? extends T> b)	组合两个Stream成一个Stream

PipelineHelper是执行流操作的流水线帮助类，捕获有关流的所有信息流水线（输出形状、中间操作、流标志、并行度、等等）：

abstract class PipelineHelper<P_OUT> {

   
    abstract StreamShape getSourceShape();

   
    abstract int getStreamAndOpFlags();

    
    abstract<P_IN> long exactOutputSizeIfKnown(Spliterator<P_IN> spliterator);

   
    abstract<P_IN, S extends Sink<P_OUT>> S wrapAndCopyInto(S sink, Spliterator<P_IN> spliterator);

    
    abstract<P_IN> void copyInto(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator);

    
    abstract <P_IN> void copyIntoWithCancel(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator);

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

函数名	作用
getSourceShape()	返回输入流的类型
getStreamAndOpFlags()	返回Stream操作标志
exactOutputSizeIfKnown(Spliterator<P_IN> spliterator)	返回Spliterator中元素数量，如果未知或无限则返回-1
wrapAndCopyInto(S sink, Spliterator<P_IN> spliterator)	将此PipelineHelper描述的管道阶段应用于spliterator并将结果发送给Sink
copyInto(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator)	将从Spliterator获得的元素推送到提供的Sink。如果已知流管道存在短路阶段，即StreamOpFlag#SHORT_CCIRCUIT，在每个元素检查Sink#cancelueRequested（），如果请求取消则停止。
copyIntoWithCancel(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator)	将从Spliterator获得的元素推送到提供的Sink，在每个元素检查Sink#cancelueRequested（），如果请求取消则停止。
wrapSink(Sink<P_OUT> sink)	获取一个 Sink，它接受PipelineHelpe，并用接受元素，并实现所有中间操作由PipelineHelper描述，将结果传递到提供的 Sink，即由wrapSink函数聚合所有的中间操作
evaluate(Spliterator<P_IN> spliterator,boolean flatten, IntFunction<P_OUT[]> generator)	收集应用管道阶段产生的所有输出元素将源Spliterator，转换为Node。

AbstractPipeline是管道类的抽象基类，这个类是核心流接口及其原语专用化的实现。管理Sink管道的操作和评估：

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;
     // 此表示的中间操作的操作标志管道对象。
      protected final int sourceOrOpFlags;
      //管道中的下一个阶段，如果这是最后一个阶段则为空。
      private AbstractPipeline nextStage;

      //此管道对象之间的中间操作数
      private int depth;
      //源和所有操作的组合源和操作标志
      private int combinedFlags;

      //源拆分器。仅对头部管道有效。
      private Spliterator<?> sourceSpliterator;
      //源 Supplier。仅对头部管道有效。
      private Supplier<? extends Spliterator<?>> sourceSupplier;
      //如果已链接或使用此管道，则为True
      private boolean linkedOrConsumed;
      //如果是并行流则返回true
      private boolean parallel;
}