简介
Java8引入Stream这个新特性之后,通过使用lambda表达式增强集合的功能,使程序员通过声明式的方式,快速和便捷的对批量数据进行过滤、转换、分组规约等操作,同时提高编程效率和代码可读性,可以说是一个真正的开发利器。本章我通过一个简单的示例,带领大家理解Stream的内部原理。
继承体系
在进入示例之前,我们先来看一下Stream的类继承结构。
图中展示的是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&g