java8新特性-引用流-peek，forEach

Stream的执行流程参考https://www.cnblogs.com/shigongp/p/17181380.html。

有时我们需要遍历所有元素并对每个元素执行操作，可以使用Stream提供的peek和forEach对每个元素进行处理。

例子：

List<User> users = new ArrayList<>();
users.add(new User("张三",30));
users.add(new User("李四",34));
users.add(new User("王五",20));


users.stream().peek(System.out::println).forEach(System.out::println);

执行结果：

源码分析

ReferencePipeline#peek(Consumer<? super P_OUT> action)

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

看到opWrapSink方法里面的Sink类Sink.ChainedReference。Sink.ChainedReference的accept调用action执行特定操作，之后调用downstream.accept将操作往下游操作传播。可看到这是个中间操作。

 
 
 

ReferencePipeline#forEach(Consumer<? super P_OUT> action)

  @Override
public void forEach(Consumer<? super P_OUT> action) {
    evaluate(ForEachOps.makeRef(action, false));
}

追踪ForEachOps.makeRef调用，最终创建

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

 static abstract class ForEachOp<T>
        implements TerminalOp<T, Void>, TerminalSink<T, Void>

由上可知OfRef是终端操作。OfRef#accept调用consumer处理元素。执行forEach后Stream会关闭。

 
 
 

peek和forEach的区别是peek是中间操作，forEach是终端操作。执行完forEach后Stream会关闭。如果只调用peek，如users.stream().peek(System.out::println)；将不会有任何输出。只有执行到了终端操作才会开始处理数据。没有终端操作就不会处理数据。