06 | Stream如何提高遍历集合效率？

一、List 集合类顶端接口 Collection。在 Java8 中，Collection 新增了两个流方法，分别是 Stream() 和 parallelStream()。

二、什么是 Stream？

1、Java8 中添加了一个新的接口类 Stream，他和我们之前接触的字节流概念不太一样

2、Java8 集合中的 Stream 相当于高级版的 Iterator

3、他可以通过 Lambda 表达式对集合进行各种非常便利、高效的聚合操作（Aggregate Operation），或者大批量数据操作 (Bulk Data Operation)。

三、Stream 的聚合操作与数据库 SQL 的聚合操作 sorted、filter、map 等类似

1、我们在应用层就可以高效地实现类似数据库 SQL 的聚合操作了

2、而在数据操作方面，Stream 不仅可以通过串行的方式实现数据操作，还可以通过并行的方式处理大批量数据，提高数据的处理效率。

四、一个简单的例子来体验下 Stream 的简洁与强大

这个 Demo 的需求是过滤分组一所中学里身高在 160cm 以上的男女同学

(student类实现了getHigh()方法和getSex()方法)

1、我们先用传统的迭代方式来实现，代码如下：

Map<String, List<Student>> stuMap = new HashMap<String, List<Student>>();
        for (Student stu: studentsList) {
            if (stu.getHeight() > 160) { //如果身高大于160
                if (stuMap.get(stu.getSex()) == null) { //该性别还没分类
                    List<Student> list = new ArrayList<Student>(); //新建该性别学生的列表
                    list.add(stu);//将学生放进去列表
                    stuMap.put(stu.getSex(), list);//将列表放到map中
                } else { //该性别分类已存在
                    stuMap.get(stu.getSex()).add(stu);//该性别分类已存在，则直接放进去即可
                }
            }
        }

2、使用 Java8 中的 Stream API 进行实现：

A、串行实现（stream()）

Map<String, List<Student>> stuMap = stuList.stream().filter((Student s) -> s.getHeight() > 160) .collect(Collectors.groupingBy(Student ::getSex)); 

B、并行实现(parallelStream())

Map<String, List<Student>> stuMap = stuList.parallelStream().filter((Student s) -> s.getHeight() > 160) .collect(Collectors.groupingBy(Student ::getSex)); 

四、Stream 如何优化遍历？

1.Stream 操作分类（他的操作分类其实是实现高效迭代大数据集合的重要原因之一）

Stream 中的操作分为两大类：

A、中间操作（Intermediate operations）

B、终结操作（Terminal operations）

C、中间操作只对操作进行了记录，即只会返回一个流，不会进行计算操作

D、而终结操作是实现了计算操作。

E、中间操作又可以分为无状态（Stateless）与有状态（Stateful）操作

a、前者是指元素的处理不受之前元素的影响

b、后者是指该操作只有拿到所有元素之后才能继续下去

F、终结操作又可以分为短路（Short-circuiting）与非短路（Unshort-circuiting）操作

a、前者是指遇到某些符合条件的元素就可以得到最终结果

b、后者是指必须处理完所有元素才能得到最终结果。

我们通常还会将中间操作称为懒操作，也正是由这种懒操作结合终结操作、数据源构成的处理管道（Pipeline），实现了 Stream 的高效

2.Stream 源码实现

A、Stream 包是由哪些主要结构类组合而成的，各个类的职责是什么。参照下图：

a、BaseStream 和 Stream 为最顶端的接口类。

aa1、BaseStream 主要定义了流的基本接口方法，例如，spliterator、isParallel 等；

aa2、Stream 则定义了一些流的常用操作方法，例如，map、filter 等。

b、ReferencePipeline 是一个结构类，他通过定义内部类组装了各种操作流。

bb1、他定义了 Head、StatelessOp、StatefulOp 三个内部类

bb2、实现了 BaseStream 与 Stream 的接口方法。

c、Sink 接口是定义每个 Stream 操作之间关系的协议

cc1、他包含 begin()、end()、cancellationRequested()、accpt() 四个方法。

cc2、ReferencePipeline 最终会将整个 Stream 流操作组装成一个调用链，而这条调用链上的各个 Stream 操作的上下关系就是通过 Sink 接口协议来定义实现的。 

3.Stream 操作叠加

A、一个 Stream 的各个操作是由处理管道组装，并统一完成数据处理的。在 JDK 中每次的中断操作会以使用阶段（Stage）命名

B、管道结构通常是由 ReferencePipeline 类实现的，ReferencePipeline 包含了 Head、StatelessOp、StatefulOp 三种内部类。

a、Head 类主要用来定义数据源操作，在我们初次调用 names.stream() 方法时，会初次加载 Head 对象，此时为加载数据源操作；

b、接着加载的是中间操作，分别为无状态中间操作 StatelessOp 对象和有状态操作 StatefulOp 对象

c、此时的 Stage 并没有执行，而是通过 AbstractPipeline 生成了一个中间操作 Stage 链表；

d、当我们调用终结操作时，会生成一个最终的 Stage，

e、通过这个 Stage 触发之前的中间操作，从最后一个 Stage 开始，递归产生一个 Sink 链。

如下图所示：

C、通过一个例子来感受下 Stream 的操作分类是如何实现高效迭代大数据集合的(串行操作)

List<String> names = Arrays.asList("张三", "李四", "王老五", "李三", "刘老四", "王小二", "张四", "张五六七");

String maxLenStartWithZ = names.stream()
                  .filter(name -> name.startsWith("张"))
                  .mapToInt(String::length)
                  .max()
                  .toString();

a 、需求是查找出一个长度最长，并且以张为姓氏的名字

b、首先 ，因为 names 是 ArrayList 集合，所以 names.stream() 方法将会调用集合类基础接口 Collection 的 Stream 方法：

    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

c 、然后，Stream 方法就会调用 StreamSupport 类的 Stream 方法，方法中初始化了一个 ReferencePipeline 的 Head 内部类对象：

 public static <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel) {
        Objects.requireNonNull(spliterator);
//定义数据源操作
        return new ReferencePipeline.Head<>(spliterator,
                                            StreamOpFlag.fromCharacteristics(spliterator),
                                            parallel);
    }

d、再调用 filter 和 map 方法，这两个方法都是无状态（拿到数据就可以进行，无需保存状态）的中间操作，所以执行 filter 和 map 操作时，并没有进行任何的操作，而是分别创建了一个 Stage 来标识用户的每一次操作。

e、一个完整的 Stage 是由数据来源、操作、回调函数组成的三元组来表示。如下图所示，分别是 ReferencePipeline 的 filter 方法和 map 方法： 

//filter
  @Override
    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类
            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);
                    }
                };
            }
        };
    }

//map
   @Override
    @SuppressWarnings("unchecked")
    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类
            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));
                    }
                };
            }
        };
    }

ee1、new StatelessOp 将会调用父类 AbstractPipeline 的构造函数，这个构造函数将前后的 Stage 联系起来，生成一个 Stage 链表： 

 AbstractPipeline(AbstractPipeline<?, E_IN, ?> previousStage, int opFlags) {
        if (previousStage.linkedOrConsumed)
            throw new IllegalStateException(MSG_STREAM_LINKED);
        previousStage.linkedOrConsumed = true;
        previousStage.nextStage = this;//将当前的stage的next指针指向之前的stage

        this.previousStage = previousStage;//赋值当前stage当全局变量previousStage 
        this.sourceOrOpFlags = opFlags & StreamOpFlag.OP_MASK;
        this.combinedFlags = StreamOpFlag.combineOpFlags(opFlags, previousStage.combinedFlags);
        this.sourceStage = previousStage.sourceStage;
        if (opIsStateful())
            sourceStage.sourceAnyStateful = true;
        this.depth = previousStage.depth + 1;
    }

ee2、因为在创建每一个 Stage 时，都会包含一个 opWrapSink() 方法，该方法会把一个操作的具体实现封装在 Sink 类中，Sink 采用（处理 -> 转发）的模式来叠加操作

f、当执行 max 方法时，会调用 ReferencePipeline 的 max 方法，此时由于 max 方法是终结操作，所以会创建一个 TerminalOp 操作，同时创建一个 ReducingSink，并且将操作封装在 Sink 类中

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

d 、最后，调用 AbstractPipeline 的 wrapSink 方法，该方法会调用 opWrapSink 生成一个 Sink 链表，Sink 链表中的每一个 Sink 都封装了一个操作的具体实现

  @Override
    @SuppressWarnings("unchecked")//生成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;
    }

g、当 Sink 链表生成完成后，Stream 开始执行，通过 spliterator 迭代集合，执行 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 会迭代集合，每迭代一次，都会执行一次 filter 操作
//如果 filter 操作通过，就会触发 map 操作，然后将结果放入到临时数组 object 中，再进行下一次的迭代。
//完成中间操作后，就会触发终结操作 max。
            spliterator.forEachRemaining(wrappedSink);
            wrappedSink.end();
        }
        else {
            copyIntoWithCancel(wrappedSink, spliterator);
        }
    }

D、还是上面的例子（并行操作） 

List<String> names = Arrays.asList("张三", "李四", "王老五", "李三", "刘老四", "王小二", "张四", "张五六七");

String maxLenStartWithZ = names.stream()
                    .parallel()/*新增一个parallel*/
                  .filter(name -> name.startsWith("张"))
                  .mapToInt(String::length)
                  .max()
                  .toString();

a、Stream 的并行处理在执行终结操作（max为终结操作）之前，跟串行处理的实现是一样的

b、在调用终结方法之后，会调用 TerminalOp 的 evaluateParallel 方法进行并行处理。 

 final <R> R evaluate(TerminalOp<E_OUT, R> terminalOp) {
        assert getOutputShape() == terminalOp.inputShape();
        if (linkedOrConsumed)
            throw new IllegalStateException(MSG_STREAM_LINKED);
        linkedOrConsumed = true;

        return isParallel()
               ? terminalOp.evaluateParallel(this, sourceSpliterator(terminalOp.getOpFlags()))
               : terminalOp.evaluateSequential(this, sourceSpliterator(terminalOp.getOpFlags()));
    }

这里的并行处理指的是

1、Stream 结合了 ForkJoin 框架，对 Stream 处理进行了分片

2、Splititerator 中的 estimateSize 方法会估算出分片的数据量。 

3、通过预估的数据量获取最小处理单元的阈值，如果当前分片大小大于最小处理单元的阈值，就继续切分集合。每个分片将会生成一个 Sink 链表，当所有的分片操作完成后，ForkJoin 框架将会合并分片任何结果集。

五、合理使用 Stream（迭代使用时间大小）

1、多核 CPU 服务器配置环境下，对比长度 100 的 int 数组的性能；

常规的迭代<Stream 并行迭代<Stream 串行迭代

2、多核 CPU 服务器配置环境下，对比长度 1.00E+8 的 int 数组的性能；

Stream 并行迭代 < 常规的迭代 <Stream 串行迭代

3、多核 CPU 服务器配置环境下，对比长度 1.00E+8 对象数组过滤分组的性能；

Stream 并行迭代 < 常规的迭代 <Stream 串行迭代

4、单核 CPU 服务器配置环境下，对比长度 1.00E+8 对象数组过滤分组的性能。

 常规的迭代 <Stream 串行迭代 <Stream 并行迭代

5、

a、在循环迭代次数较少的情况下，常规的迭代方式性能反而更好；

b、在单核 CPU 服务器配置环境中，也是常规迭代方式更有优势；

c、而在大数据循环迭代中，如果服务器是多核 CPU 的情况下，Stream 的并行迭代优势明显。所以我们在平时处理大数据的集合时，应该尽量考虑将应用部署在多核 CPU 环境下，并且使用 Stream 的并行迭代方式进行处理

六、小结

1、Stream 将整个操作分解为了链式结构，不仅简化了遍历操作，还为实现了并行计算打下了基础。

2、Stream 将遍历元素的操作和对元素的计算分为中间操作和终结操作，而中间操作又根据元素之间状态有无干扰分为有状态和无状态操作，实现了链结构中的不同阶段。

3、在串行处理操作中，Stream 在执行每一步中间操作时，并不会做实际的数据操作处理，而是将这些中间操作串联起来，最终由终结操作触发，生成一个数据处理链表，通过 Java8 中的 Spliterator 迭代器进行数据处理（每执行一次迭代，就对所有的无状态的中间操作进行数据处理，而对有状态的中间操作，就需要迭代处理完所有的数据，再进行处理操作；最后就是进行终结操作的数据处理。）

4、在并行处理操作中，Stream 对中间操作基本跟串行处理方式是一样的，但在终结操作中，Stream 将结合 ForkJoin 框架对集合进行切片处理，ForkJoin 框架将每个切片的处理结果 Join 合并起来。

5、最后就是要注意 Stream 的使用场景。