Stream collect 核心源码解读

使用示例代码

        //一个string数组流对象
        Stream<String> streamList = Stream.of("aa","bb","cb","dg");
        /**
         * 第一个参数： 接受一个需要返回的类型的空对象 ，作为最后返回的容器
         * 第二个参数： 获取当前流中的元素，存入到容器【第一个对象】
         * 第三个参数： 猜测：1、因为流支持链式编程  2、为了支持并行流
         *  第三个参数，会将之前的流处理的返回结果集合并的当前容器【第一个参数】，
         * 最后返回包含所有数据的集合
         */
        List<String> list1 = streamList.collect(
            () -> new ArrayList(),
            (theList,item) -> theList.add(item),
            (theList,theList2) ->theList.addAll(theList2)
        );

接口中用到的函数式接口简介

//没有入参，返回一个需要的对象 
@FunctionalInterface
public interface Supplier<T> { T get(); }

//两个入参，通过accept实现类处理 ，无出参
@FunctionalInterface
public interface BiConsumer<T, U> { void accept(T t, U u); }

源码解析

Stream类中的接口

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

实现类 : 主要调用了ReduceOps.makeRef

supplier ：供应商
accumulator： 蓄电池
combiner ： 组合器，合成仪

abstract class ReferencePipeline<P_IN, P_OUT>
        extends AbstractPipeline<P_IN, P_OUT, Stream<P_OUT>>
        implements Stream<P_OUT>  {
    @Override
    public final <R> R collect(Supplier<R> supplier,
        BiConsumer<R, ? super P_OUT> accumulator,
        BiConsumer<R, R> combiner) {
        return evaluate(ReduceOps.makeRef(supplier, accumulator, combiner));
    }
}

ReduceOps.makeRef 方法解析

   seed : 种子、起源  --- 将初始容器作为赋值给需要返回的对象state
	accumulator： 蓄电池 : 调用用户实现的accept方法【theList.add(item)】
	reducer：还原剂;减速器; 调用用户实现的accept方法【theList.addAll(theList2)】

public static <T, R> TerminalOp<T, R>
    makeRef(Supplier<R> seedFactory,
            BiConsumer<R, ? super T> accumulator,
            BiConsumer<R,R> reducer) {     
        // ReducingSink  Box 两个内部类  
        class ReducingSink extends Box<R>
                implements AccumulatingSink<T, R, ReducingSink> {
            @Override
            public void begin(long size) {
                state = seedFactory.get();
            }

            @Override
            public void accept(T t) {
                accumulator.accept(state, t);
            }

            @Override
            public void combine(ReducingSink other) {
                reducer.accept(state, other.state);
            }
        }
        return new ReduceOp<T, R, ReducingSink>(StreamShape.REFERENCE) {
            @Override
            public ReducingSink makeSink() {
                return new ReducingSink();
            }
        };
    }

ReduceOps内部类Box

    private static abstract class Box<U> {
    	//最终返回state对象
        U state;
        public U get() { return state; }
    }