从0开始实现java Stream功能

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流在使用过程中的三个阶段

  1. 生成并构造一个流 (List.stream 等方法)

  2. 在流的处理过程中添加或绑定惰性求值流程 (map、flatMap、filter、limit 等方法)

  3. 对流使用强制求值函数,计算最终结果 (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):

  1. 最初生成流的求值过程返回了空流(整数流,low > high 时,返回空流 )
  2. 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

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值