java8 stream介绍
java8新增了stream流的特性,能够让用户以函数式的方式、更为简单的操纵集合等数据结构,并实现了用户无感知的并行计算。
相信很多人在使用过java8的streamAPI接口之后,都会对其实现原理感到好奇,但往往在看到jdk的stream源码后却被其复杂的抽象、封装给弄糊涂了,而无法很好的理解其背后的原理。究其原因,是因为jdk的stream源码是高度工程化的代码,工程化的代码为了效率和满足各式各样的需求,会将代码实现的极其复杂,不易理解。
在这里,我们将抛开jdk的实现思路,从零开始实现一个stream流。
我们的stream流同样拥有惰性求值,函数式编程接口等特性,并兼容jdk的Collection等数据结构(但不支持并行计算 orz)。
相信在亲手实现一个stream流的框架之后,大家能更好的理解流计算的原理。
stream的优点
在探讨探究stream的实现原理和动手实现之前,我们先要体会stream流计算的独特之处。
举个例子: 有一个List列表,我们需要获得年龄为70岁的前10个Person的姓名。
**过程式的解决方案:**稍加思考,我们很快就写出了一个过程式的解决方案(伪代码):
List<Person> personList = queryDB(); // 获得List<Person>
int limit = 10; // 限制条件
List<String> nameList = new ArrayList(); // 收集的姓名集合
for(Person personItem : personList){
if(personItem.age == 70){ // 满足条件
nameList.add(personItem.name); // 加入姓名集合
if(nameList.size() >= 10){ // 判断是否超过限制
break;
}
}
}
return nameList;
**函数式stream解决方案:**下面我们给出一种基于stream流的解决方案(伪代码):
List<Person> personList = queryDB(); // 获得List<Person>
List<String> nameList = personList.stream()
.filter(item->item.age == 70) // 过滤条件
.limit(10) // limit限制条件
.map(item->item.name) // 获得姓名
.collect(Collector.toList()); // 转化为list
return nameList;
两种方案的不同之处:
从函数式的角度上看,过程式的代码实现将收集元素、循环迭代、各种逻辑判断耦合在一起,暴露了太多细节。当未来需求变动和变得更加复杂的情况下,过程式的代码将变得难以理解和维护(需要控制台打印出 年龄为70岁的前10个Person中,姓王的Person的名称)。
函数式的解决方案解开了代码细节和业务逻辑的耦合,类似于sql语句,表达的是**“要做什么"而不是"如何去做”**,使程序员可以更加专注于业务逻辑,写出易于理解和维护的代码。
List<Person> personList = queryDB(); // 获得List<Person>
personList.stream()
.filter(item->item.age == 70) // 过滤条件
.limit(10) // limit限制条件
.filter(item->item.name.startWith("王")) // 过滤条件
.map(item->item.name) // 获得姓名
.forEach(System.out::println);
自己实现stream流功能
stream流在使用过程中的三个阶段:
-
生成并构造一个流 (List.stream 等方法)
-
在流的处理过程中添加或绑定惰性求值流程 (map、flatMap、filter、limit 等方法)
-
对流使用强制求值函数,计算最终结果 (max、collect、forEach等方法
**stream流的特点:**流的结构类似于链表,不同的是流的下一个节点是以表达式的形式进行封装的,我们在调用map,flagMap等操作时并没有对节点进行操作,而操作的是节点所对应的表达式。只有在调用强制求值操作时才会调用表达式获取真正的流对象。(惰性求值)
举个例子:有一个从1到5的流,我们调用map将每个元素乘以10最后进行打印:
//在map之前,每个节点的表达式是这样的 Supplier numSup = ()->num,调用map后其实是对表达式再次进行封装变为
// Supplier newSup= ()->numSup.apply()*10
IntStream.range(1,6)
.map(n -> n*10) // 元素*10
.forEach(System.out::println); // 打印
stream流定义
流本身
@AllArgsConstructor(access = AccessLevel.PROTECTED)
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class StreamNode<T> {
//当前节点的数据
protected T value;
//用于获取下一个节点的表达式
protected StreamNodeSupplier<T> nextNode;
//是否开始节点
protected boolean start;
//是否结束节点
public boolean isEnd(){
return Objects.isNull(this.nextNode);
}
}
StreamNodeSupplier
public class StreamNodeSupplier<T> {
public Supplier<StreamNode<T>> supplier;
public StreamNodeSupplier(Supplier<StreamNode<T>> supplier){
this.supplier = supplier;
}
public StreamNode<T> get(){
return this.supplier.get();
}
}
StreamNode构造类
public class StreamNodeBuilder<T> {
public static<T> StreamNode<T> node(T value,StreamNodeSupplier<T> nextNode){
StreamNode<T> streamNode = new StreamNode<>();
streamNode.value = value;
streamNode.nextNode = nextNode;
return streamNode;
}
public static<T> StreamNode<T> startNode(StreamNodeSupplier<T> nextNode){
StreamNode<T> streamNode = new StreamNode<>();
streamNode.nextNode = nextNode;
streamNode.start = true;
return streamNode;
}
public static<T> StreamNode<T> endNode(T value){
StreamNode<T> streamNode = new StreamNode<>();
streamNode.value = value;
return streamNode;
}
}
如何生成Stream
我们以一个Integer整数流的生成为例。IntStreamGen.IntStreamGen(1,10) 会返回一个流结构,其逻辑上等价于一个从1到10的整数流。但实质是一个惰性求值的stream对象,这里称其为IntStream,其StreamNodeSupplier是一个闭包,方法体是一个递归结构的求值函数,其中下界参数low = low + 1。
当IntStream第一次被求值时,流开始初始化,isStart = true。当初始化完成之后,每一次求值,都会生成一个新的流对象,其中head(low) = low + 1。当low > high时,流被终止,返回空的流对象。
public class IntStreamGen {
public static StreamNode<Integer> gen(int start,int end){
return gen(start,end,true);
}
public static StreamNode<Integer> gen(int start, int end, boolean isStart){
//如果是开始节点,构建一个开始节点
if(isStart){
return StreamNodeBuilder.startNode(new StreamNodeSupplier<>(() -> gen(start,end,false)));
}
//判断是否结束
boolean isEnd = start >= end;
//生成下一节点的供应商
StreamNodeSupplier<Integer> nextNode = isEnd ? null : new StreamNodeSupplier<>( ()-> gen(start+1,end,false) );
//返回
return StreamNodeBuilder.node(start,nextNode);
}
}
可以看到,**生成一个流的关键在于确定如何求值下一项元素。**对于整数流来说,low = low + 1就是其下一项的求值过程。
那么对于我们非常关心的jdk集合容器,又该如何生成对应的流呢?
答案是Iterator迭代器,jdk的集合容器都实现了Iterator迭代器接口,通过迭代器我们可以轻易的取得容器的下一项元素,而不用关心容器内部实现细节。换句话说,只要实现过迭代器接口,就可以自然的转化为stream流,从而获得流计算的所有能力。
public class CollStreamGen {
public static<T> StreamNode<T> gen(Collection<T> coll){
return gen(coll.iterator());
}
public static<T> StreamNode<T> gen(Iterator<T> iterator){
return gen(iterator,true);
}
private static<T> StreamNode<T> gen(Iterator<T> iterator,boolean isStart){
//判断是否有值
boolean isEnd = !iterator.hasNext();
//计算下一个值的供应商
Supplier<StreamNodeSupplier<T>> supplier = ()->{
return !iterator.hasNext() ? null : new StreamNodeSupplier<>(()-> gen(iterator,false));
};
if( isStart){
return StreamNodeBuilder.node(null,supplier.get());
}
return StreamNodeBuilder.node(isEnd ? null : iterator.next(),supplier.get());
}
}
实现stream的功能
在流的处理过程中添加、绑定惰性求值流程
我们以map接口举例说明。API的map接口是一个惰性求值接口,在流执行了map方法后(stream.map()),不会进行任何的求值运算。map在执行时,会生成一个新的求值过程StreamNodeSupplier,新的过程将之前流的求值过程给**“包裹"起来了,仅仅是在"流的生成"到"流的最终求值”**之间增加了一道处理工序,最终返回了一个新的stream流对象。
API.map所依赖的内部静态map方法是一个惰性求值方法,其每次调用**"只会"将当前流的head部分进行map映射操作,并且生成一个新的流。新生成流的StreamNodeSupplier和之前逻辑基本保持一致(递归),唯一的区别是,第二个参数传入的stream在调用方法之前会被强制求值(eval)**后再传入
惰性求值接口的实现大同小异,大家需要体会一下闭包、递归、惰性求值等概念。
map
public <R> StreamNode<R> map(Function<T,R> function){
return map(function,this);
}
private <R> StreamNode<R> map(Function<T,R> function,StreamNode<T> node){
//计算当前值
R newValue = node.start ? null : function.apply(node.value);
//计算子节点提供者
StreamNodeSupplier<R> supplier = node.isEnd() ? null : new StreamNodeSupplier<>( ()-> map(function,node.nextNode.get()));
return new StreamNode<>(newValue,supplier,node.start);
}
flatMap
public <R> StreamNode<R> flatMap(Function<T,StreamNode<R>> mapper){
//如果当前流是空的,直接返回
if(this.isEnd())return new StreamNode<R>(null,null,this.start);
//方便 lambda 调用
StreamNodeSupplier<T> oldNodeSupplier = this.nextNode;
StreamNodeSupplier<R> newNodeSupplier = new StreamNodeSupplier<>(() -> {
StreamNode<T> streamNode = oldNodeSupplier.get();
return flatMap(mapper, new StreamNode<R>(null, null, false), streamNode);
});
return new StreamNode<R>(null,newNodeSupplier,true).nextNode.get();
}
private static <R,T> StreamNode<R> flatMap(Function<T,? extends StreamNode<R>> mapper, StreamNode<R> headStreamNode, StreamNode<T> streamNode){
//如果头节点当前不是最后一个节点
if(!headStreamNode.isEnd()){
//头节点未结束,继续拼接
return new StreamNode<>(headStreamNode.value, new StreamNodeSupplier<>(() -> flatMap(mapper, headStreamNode.nextNode.get(), streamNode)), false);
}
//如果头节点当前是最后一个节点
//如果当前流结束,拼接
if(streamNode.isEnd()){
//计算获取新节点
StreamNodeSupplier<R> nextNodeSupplier = mapper.apply(streamNode.value).nextNode;
//创建新新节点拼接2个节点
return StreamNodeBuilder.node(headStreamNode.value,nextNodeSupplier);
}
//当前流没结束
StreamNode<R> newHeadMyStream = mapper.apply(streamNode.value).nextNode.get();
//将当前节点的子节点作为头结点继续递归拼接
return StreamNodeBuilder.node(headStreamNode.value,new StreamNodeSupplier<>(()->flatMap(mapper,newHeadMyStream,streamNode.nextNode.get())));
}
filter
public StreamNode<T> filter(Predicate<T> predicate){
if(this.isEnd()) return this;
//闭包
StreamNodeSupplier<T> nextNodeSupplier = this.nextNode;
this.nextNode = filter(predicate,nextNodeSupplier.get());
return this;
}
private StreamNodeSupplier<T> filter(Predicate<T> predicate,StreamNode<T> node){
boolean through = predicate.test(node.value);
if(through){
//惰性求值
return new StreamNodeSupplier<>(()->{
return node.isEnd() ? node : StreamNodeBuilder.node( node.value,filter( predicate,node.nextNode.get() ) );
});
}
//递归
return node.isEnd() ? null : filter(predicate,node.nextNode.get());
}
limit
public StreamNodeSupplier<T> limit(int n,StreamNode<T> node){
if(n ==0 || node.isEnd()) return null;
node.nextNode = limit(--n,node.nextNode.get());
return new StreamNodeSupplier<>(()->node);
}
private StreamNodeSupplier<T> limit(int n,StreamNode<T> node){
if(n ==0 || node.isEnd()) return null;
node.nextNode = limit(--n,node.nextNode.get());
return new StreamNodeSupplier<>(()->node);
}
distinct
public StreamNode<T> distinct(){
//闭包
StreamNodeSupplier<T> nextNodeSupplier = this.nextNode;
//惰性求值
this.nextNode = new StreamNodeSupplier<>(()->distinct(new HashSet<>(),nextNodeSupplier.get()).get());
return this;
}
private StreamNodeSupplier<T> distinct(HashSet<T> hashSet,StreamNode<T> streamNode){
final boolean contains = hashSet.contains(streamNode.value);
if(contains && streamNode.isEnd()){
return null;
}
if(contains){
return distinct(hashSet,streamNode.nextNode.get());
}
hashSet.add(streamNode.value);
//递归
return new StreamNodeSupplier<>(()-> {
streamNode.nextNode = distinct(hashSet,streamNode.nextNode.get());
return streamNode;
});
}
对流使用强制求值函数,生成最终结果
我们以forEach方法举例说明。强制求值方法forEach会不断的对当前stream进行求值并让consumer接收处理,直到当前流成为空流。
有两种可能的情况会导致递归传入的流参数成为空流(empty-stream):
- 最初生成流的求值过程返回了空流(整数流,low > high 时,返回空流 )
- limit之类的短路操作,会提前终止流的求值返回空流(n == 0 时,返回空流)
public void forEach(Consumer<T> function){
forEach(function,this);
}
private void forEach(Consumer<T> function,StreamNode<T> node){
//如果是子节点,直接返回
if(node.isEnd()) return;
//获取子节点
StreamNode<T> streamNode = node.nextNode.get();
//调用消费者处理
function.accept(streamNode.value);
//递归处理子节点
if(!node.isEnd()) forEach(function,streamNode);
}
参考博客: https://blog.csdn.net/qq_33591903/article/details/110529814