java-stream-自定义stream
一、流程
1
// 自定义集合，继承ArrayList，与ArrayList没啥区别 SelfList<Apple> appleList = new SelfList<>();
import java.util.ArrayList; import java.util.Iterator; /** * 自定义集合，继承ArrayList，与ArrayList没啥区别 */ public class SelfList<T> extends ArrayList<T> { /** * 数据源放进头部管道，头部管段很窄，深度为0，没有sink操作 * * @return 头部管道（作用是持有数据源） */ public SelfStream<T> selfStream() { Iterator<T> listIterator = super.iterator(); return new SelfPipeline.SelfHead<>(listIterator); } }
/** * 头部管道：继承管道，属于管道的一种 */ static class SelfHead<P_IN, P_OUT> extends SelfPipeline<P_IN, P_OUT> { SelfHead(Iterator<?> source) { // 初始化头部管道 super(source);
/** * 初始化头部管道 * * @param source 数据源 */ SelfPipeline(Iterator<?> source) { // 数据源 this.sourceIterator = source; // 数据源Op，即是头部管道自身，后面每一段管道通过持有“头部管道”获取数据源 this.sourceStage = this; // 上段管道，头部管道没有上段管道 this.previousStage = null; // 头部管道的深度=0，下面的每段管道的深度依次+1 this.depth = 0; }
} // 头部管道无需sink @Override final SelfSink<P_IN> opWrapSink(SelfSink<P_OUT> sink) { throw new UnsupportedOperationException(); } }
appleList.add(new Apple(1, "青色")); appleList.add(new Apple(2, "橙色")); appleList.add(new Apple(3, "红色")); appleList.add(new Apple(4, "绿色")); appleList.add(new Apple(5, "绿色")); appleList.add(new Apple(6, "紫色"));
2
// 把数据源（appleList）放进头部管道（pipelineHead），接下来每段管道都持有头部管道以获取数据源 SelfStream<Apple> pipelineHead = appleList.selfStream();
见SelfList
3
// 线性拼接下一段管道（FilterOp），并定义这段管道的职责（计划由FilterSink执行） SelfStream<Apple> statelessOpFilter = pipelineHead.filter(item -> "绿色".equals(item.getColor()));
/** * 生成Op管道（FilterOp），定义这段管道的职责（并由FilterSink执行该职责） * * @param predicate 断言型函数式接口 * @return Op管道（FilterOp） */ @Override public final SelfStream<P_OUT> filter(Predicate<? super P_OUT> predicate) { return new SelfStatelessOp<P_OUT, P_OUT>(this) {
/** * Op管道：继承管道，属于管道的一种 */ abstract static class SelfStatelessOp<P_IN, P_OUT> extends SelfPipeline<P_IN, P_OUT> { /** * @param upstream 上段管道 */ SelfStatelessOp(SelfPipeline<?, P_IN> upstream) { // 初始化Op管道 super(upstream);
/** * 初始化Op管道 * * @param upstream 上段管道 */ SelfPipeline(SelfPipeline<?, P_IN> upstream) { // 自己的上段管道 this.previousStage = upstream; // 上段管道的下段是自己 upstream.nextStage = this; // 每一段管道都持有“头部管道” this.sourceStage = upstream.sourceStage; // 深度+1 this.depth = upstream.depth + 1; }
}
}
// 定义这段管道的职责（并由FilterSink执行该职责） @Override SelfSink<P_OUT> opWrapSink(SelfSink<P_OUT> sink) { // FilterSink return new SelfSink.Chain<P_OUT, P_OUT>(sink) {
/** * sink链 */ abstract class Chain<T, E_OUT> implements SelfSink<T> { // 下个sink protected final SelfSink<? super E_OUT> downstream; public Chain(SelfSink<? super E_OUT> downstream) { // 向下的单向链条 this.downstream = downstream; } // 本例：单向链条传递到最后一个ReducingSink，初始化结果集合 @Override public void begin(long size) { downstream.begin(size); } }
@Override public void begin(long size) { downstream.begin(-1); } @Override public void accept(P_OUT u) { if (predicate.test(u)) { // 触发下一段管道的动作，下沉 downstream.accept(u); } } }; } }; }
4
// 线性拼接下一段管道（MapOp），并定义这段管道的职责（计划由MapSink执行） SelfStream<Integer> statelessOpMap = statelessOpFilter.map(Apple::getWeight);
/** * 生成Op管道（MapOp），定义这段管道的职责（并由MapSink执行该职责） * * @param mapper 函数型函数式接口：有入参和返回值 * @return Op管道（MapOp） */ @Override public final <R> SelfStream<R> map(Function<? super P_OUT, ? extends R> mapper) { return new SelfStatelessOp<P_OUT, R>(this) {
如上FilterOp
// 定义这段管道的职责（并由MapSink执行该职责） @Override SelfSink<P_OUT> opWrapSink(SelfSink<R> sink) { // MapSink return new SelfSink.Chain<P_OUT, R>(sink) {
如上FilterOp
@Override public void accept(P_OUT u) { downstream.accept(mapper.apply(u)); } }; } }; }
5
/* * 执行终结操作： * 1，生成ReducingSink（设计为收集汇聚上游的流）； * 2，生成MapSink，让MapSink向下链接ReducingSink； * 3，通过MapOp来到FilterOp，生成FilterSink，让FilterSink向下链接MapSink； * 4，遍历数据源的每一个元素，让元素依次流经FilterSink->MapSink->ReducingSink，汇聚成最终形态 */ SelfList<Integer> terminalOpCollect = statelessOpMap.collect(SelfCollectors.toList());
/** * 终结操作 * * @param collector 此例子是Collectors.toList()，定义了结果集和操作结果集的方法 * @return 最终结果：即汇聚最终结果都是在此方法中进行的 */ @Override public final <R, A> R collect(SelfCollector<? super P_OUT, A> collector) { // 在终结操作里尾部管道（TerminalOp) SelfTerminalOp<P_OUT, A> terminalOp = SelfReduceOpsFactory.makeRef(collector);
// 生成尾部管道 public static <T, I> SelfTerminalOp<T, I> makeRef(SelfCollector<? super T, I> collector) { // 此例子是(Supplier<List<T>>) ArrayList::new Supplier<I> supplier = Objects.requireNonNull(collector).supplier(); // 此例子是List::add BiConsumer<I, ? super T> accumulator = collector.accumulator(); // 定义了ReducingSink的职责 class ReducingSink extends SelfBox<I> implements SelfTerminalSink<T, I> { @Override public void begin(long size) { // state = ArrayList::new = 初始化的空集合 state = supplier.get(); } @Override public void accept(T t) { // 向集合state中添加元素t accumulator.accept(state, t); } } // 生成ReduceOp（尾部管道接口的实现类），定义尾部管道的职责（并由ReducingSink执行该职责） return new SelfReduceOp<T, I, ReducingSink>() { // ReducingSink @Override public ReducingSink makeSink() { return new ReducingSink(); } }; }
// 拉网 A container = evaluate(terminalOp);
/** * 使用terminalOp拉网 * * @param terminalOp 使用statelessOp.collect方法的参数构造出来的 * @param <R> * @return 拉网结果，ReducingSink的get方法得到最终集合 */ final <R> R evaluate(SelfTerminalOp<P_OUT, R> terminalOp) { // 当前对象为map的statelessOp Iterator<?> iterator = sourceStage.sourceIterator; // 按顺序拉网：terminalOp是使用statelessOp.collect方法的参数构造出来的 return terminalOp.evaluateSequential(this, iterator);
/** * 顺序评估管道 */ @Override public <P_IN> R evaluateSequential(SelfPipelineHelper<T> helper, Iterator<P_IN> iterator) { // 生成尾部管道的sink S reducingSink = makeSink();
如上makeRef
// 管道包装sink：从ReducingSink（4）开始，按照3,4；2,3；1,2的顺序构建sink链，按照1,2,3,4的顺序执行流转，由4收集最终结果 S wrappedReducingSink = helper.wrapAndCopyInto(reducingSink, iterator);
/** * 管道包装sink * * @return 评估管道结束后，返回终结操作管道的sink */ @Override final <P_IN, S extends SelfSink<P_OUT>> S wrapAndCopyInto(S sink, Iterator<P_IN> iterator) { // 向前遍历管道，根据管道之前的职责定义，包装生成对应的sink，并使用链条串联起来；返回sink链的第一个对象 SelfSink<P_IN> firstSinkLink = wrapSink(Objects.requireNonNull(sink));
/** * 管道包装sink * * @param sink 此例子是：传入的是ReducingSink * @return sink链的第一个对象 */ @Override final <P_IN> SelfSink<P_IN> wrapSink(SelfSink<P_OUT> sink) { // 向前遍历管道，根据管道之前的职责定义，包装生成对应的sink，并使用链条串联起来 for (SelfPipeline p = SelfPipeline.this; p.depth > 0; p = p.previousStage) { sink = p.opWrapSink(sink);
见FilterOp、MapOp的职责定义部分
} return (SelfSink<P_IN>) sink; }
// 数据源的每一个元素都从sink链的第一个对象流转到最后一个对象，并被最后一个对象收集 copyInto(firstSinkLink, iterator);
/** * 遍历数据源元素，顺序执行sink的accept方法（consumer） * * @param wrappedSink sink链的第一个对象 * @param iterator 数据源 */ @Override final <P_IN> void copyInto(SelfSink<P_IN> wrappedSink, Iterator<P_IN> iterator) { // 准备好尾部管道的收集装置 wrappedSink.begin(-1); // 遍历流转和收集 iterator.forEachRemaining(wrappedSink);
// 收尾工作（无） wrappedSink.end(); }
// 返回ReducingSink return sink; }
// 返回ReducingSink持有和可以supplier的集合 return wrappedReducingSink.get(); }
}
return (R) container; }
6
System.out.println(terminalOpCollect);
7
// 简写 SelfList<Integer> apples = appleList.selfStream() .filter(item -> "绿色".equals(item.getColor())) .map(Apple::getWeight) .collect(SelfCollectors.toList()); System.out.println(apples);
二、完整代码
package com.simple.boot.java_skill.selfλ; import com.simple.boot.java_skill.functionprograming.Apple; /** * main函数 */ public class SelfLambdaTest { public static void main(String[] args) { // 自定义集合，继承ArrayList，与ArrayList没啥区别 SelfList<Apple> appleList = new SelfList<>(); appleList.add(new Apple(1, "青色")); appleList.add(new Apple(2, "橙色")); appleList.add(new Apple(3, "红色")); appleList.add(new Apple(4, "绿色")); appleList.add(new Apple(5, "绿色")); appleList.add(new Apple(6, "紫色")); // 把数据源（appleList）放进头部管道（pipelineHead），接下来每段管道都持有头部管道以获取数据源 SelfStream<Apple> pipelineHead = appleList.selfStream(); // 线性拼接下一段管道（FilterOp），并定义这段管道的职责（计划由FilterSink执行） SelfStream<Apple> statelessOpFilter = pipelineHead.filter(item -> "绿色".equals(item.getColor())); // 线性拼接下一段管道（MapOp），并定义这段管道的职责（计划由MapSink执行） SelfStream<Integer> statelessOpMap = statelessOpFilter.map(Apple::getWeight); /* * 执行终结操作： * 1，生成ReducingSink（设计为收集汇聚上游的流）； * 2，生成MapSink，让MapSink向下链接ReducingSink； * 3，通过MapOp来到FilterOp，生成FilterSink，让FilterSink向下链接MapSink； * 4，遍历数据源的每一个元素，让元素依次流经FilterSink->MapSink->ReducingSink，汇聚成最终形态 */ SelfList<Apple> terminalOpCollect = statelessOpMap.collect(SelfCollectors.toList()); System.out.println(terminalOpCollect); // 简写 SelfList<Apple> apples = appleList.selfStream() .filter(item -> "绿色".equals(item.getColor())) .map(Apple::getWeight) .collect(SelfCollectors.toList()); System.out.println(apples); } }
package com.simple.boot.java_skill.selfλ; import java.util.ArrayList; import java.util.Iterator; /** * 自定义集合，继承ArrayList，与ArrayList没啥区别 */ public class SelfList<T> extends ArrayList<T> { /** * 数据源放进头部管道，头部管段很窄，深度为0，没有sink操作 * * @return 头部管道（作用是持有数据源） */ public SelfStream<T> selfStream() { Iterator<T> listIterator = super.iterator(); return new SelfPipeline.SelfHead<>(listIterator); } }
package com.simple.boot.java_skill.selfλ; import java.util.Iterator; import java.util.Objects; import java.util.function.Function; import java.util.function.Predicate; /** * 管道：流的一种具化实现 */ public abstract class SelfPipeline<P_IN, P_OUT> extends SelfPipelineHelper<P_OUT> implements SelfStream<P_OUT> { // 数据源 private Iterator<?> sourceIterator; // 头部管道（持有数据源） private final SelfPipeline sourceStage; // 上段管道 private final SelfPipeline previousStage; // 下段管道 private SelfPipeline nextStage; // 本段管道深度 private int depth; /** * 初始化Op管道 * * @param upstream 上段管道 */ SelfPipeline(SelfPipeline<?, P_IN> upstream) { // 自己的上段管道 this.previousStage = upstream; // 上段管道的下段是自己 upstream.nextStage = this; // 每一段管道都持有“头部管道” this.sourceStage = upstream.sourceStage; // 深度+1 this.depth = upstream.depth + 1; } /** * 初始化头部管道 * * @param source 数据源 */ SelfPipeline(Iterator<?> source) { // 数据源 this.sourceIterator = source; // 数据源Op，即是头部管道自身，后面每一段管道通过持有“头部管道”获取数据源 this.sourceStage = this; // 上段管道，头部管道没有上段管道 this.previousStage = null; // 头部管道的深度=0，下面的每段管道的深度依次+1 this.depth = 0; } /** * 头部管道：继承管道，属于管道的一种 */ static class SelfHead<P_IN, P_OUT> extends SelfPipeline<P_IN, P_OUT> { SelfHead(Iterator<?> source) { // 初始化头部管道 super(source); } // 头部管道无需sink @Override final SelfSink<P_IN> opWrapSink(SelfSink<P_OUT> sink) { throw new UnsupportedOperationException(); } } /** * Op管道：继承管道，属于管道的一种 */ abstract static class SelfStatelessOp<P_IN, P_OUT> extends SelfPipeline<P_IN, P_OUT> { /** * @param upstream 上段管道 */ SelfStatelessOp(SelfPipeline<?, P_IN> upstream) { // 初始化Op管道 super(upstream); } } abstract SelfSink<P_IN> opWrapSink(SelfSink<P_OUT> sink); /** * 生成Op管道（FilterOp），定义这段管道的职责（并由FilterSink执行该职责） * * @param predicate 断言型函数式接口 * @return Op管道（FilterOp） */ @Override public final SelfStream<P_OUT> filter(Predicate<? super P_OUT> predicate) { return new SelfStatelessOp<P_OUT, P_OUT>(this) { // 定义这段管道的职责（并由FilterSink执行该职责） @Override SelfSink<P_OUT> opWrapSink(SelfSink<P_OUT> sink) { // FilterSink return new SelfSink.Chain<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); } } }; } }; } /** * 生成Op管道（MapOp），定义这段管道的职责（并由MapSink执行该职责） * * @param mapper 函数型函数式接口：有入参和返回值 * @return Op管道（MapOp） */ @Override public final <R> SelfStream<R> map(Function<? super P_OUT, ? extends R> mapper) { return new SelfStatelessOp<P_OUT, R>(this) { // 定义这段管道的职责（并由MapSink执行该职责） @Override SelfSink<P_OUT> opWrapSink(SelfSink<R> sink) { // MapSink return new SelfSink.Chain<P_OUT, R>(sink) { @Override public void accept(P_OUT u) { downstream.accept(mapper.apply(u)); } }; } }; } /** * 终结操作 * * @param collector 此例子是Collectors.toList()，定义了结果集和操作结果集的方法 * @return 最终结果：即汇聚最终结果都是在此方法中进行的 */ @Override public final <R, A> R collect(SelfCollector<? super P_OUT, A> collector) { // 在终结操作里尾部管道（TerminalOp) SelfTerminalOp<P_OUT, A> terminalOp = SelfReduceOpsFactory.makeRef(collector); // 拉网 A container = evaluate(terminalOp); return (R) container; } /** * 使用terminalOp拉网 * * @param terminalOp 使用statelessOp.collect方法的参数构造出来的 * @param <R> * @return 拉网结果，ReducingSink的get方法得到最终集合 */ final <R> R evaluate(SelfTerminalOp<P_OUT, R> terminalOp) { // 当前对象为map的statelessOp Iterator<?> iterator = sourceStage.sourceIterator; // 按顺序拉网：terminalOp是使用statelessOp.collect方法的参数构造出来的 return terminalOp.evaluateSequential(this, iterator); } /** * 管道包装sink * * @return 评估管道结束后，返回终结操作管道的sink */ @Override final <P_IN, S extends SelfSink<P_OUT>> S wrapAndCopyInto(S sink, Iterator<P_IN> iterator) { // 向前遍历管道，根据管道之前的职责定义，包装生成对应的sink，并使用链条串联起来；返回sink链的第一个对象 SelfSink<P_IN> firstSinkLink = wrapSink(Objects.requireNonNull(sink)); // 数据源的每一个元素都从sink链的第一个对象流转到最后一个对象，并被最后一个对象收集 copyInto(firstSinkLink, iterator); // 返回ReducingSink return sink; } /** * 遍历数据源元素，顺序执行sink的accept方法（consumer） * * @param wrappedSink sink链的第一个对象 * @param iterator 数据源 */ @Override final <P_IN> void copyInto(SelfSink<P_IN> wrappedSink, Iterator<P_IN> iterator) { // 准备好尾部管道的收集装置 wrappedSink.begin(-1); // 遍历流转和收集 iterator.forEachRemaining(wrappedSink); // 收尾工作（无） wrappedSink.end(); } /** * 管道包装sink * * @param sink 此例子是：传入的是ReducingSink * @return sink链的第一个对象 */ @Override final <P_IN> SelfSink<P_IN> wrapSink(SelfSink<P_OUT> sink) { // 向前遍历管道，根据管道之前的职责定义，包装生成对应的sink，并使用链条串联起来 for (SelfPipeline p = SelfPipeline.this; p.depth > 0; p = p.previousStage) { sink = p.opWrapSink(sink); } return (SelfSink<P_IN>) sink; } }
package com.simple.boot.java_skill.selfλ; import java.util.function.BiConsumer; import java.util.function.Supplier; public interface SelfCollector<T, A> { Supplier<A> supplier(); BiConsumer<A, T> accumulator(); }
package com.simple.boot.java_skill.selfλ; import java.util.List; import java.util.function.BiConsumer; import java.util.function.Supplier; public final class SelfCollectors { public static <T> SelfCollector<T, ?> toList() { return new SelfCollectorImpl<>((Supplier<List<T>>) SelfList::new, List::add); } static class SelfCollectorImpl<T, A> implements SelfCollector<T, A> { private final Supplier<A> supplier; private final BiConsumer<A, T> accumulator; SelfCollectorImpl(Supplier<A> supplier, BiConsumer<A, T> accumulator) { this.supplier = supplier; this.accumulator = accumulator; } @Override public BiConsumer<A, T> accumulator() { return accumulator; } @Override public Supplier<A> supplier() { return supplier; } } }
package com.simple.boot.java_skill.selfλ; import java.util.Iterator; /** * 管道工具类 */ public abstract class SelfPipelineHelper<P_OUT> { abstract <P_IN, S extends SelfSink<P_OUT>> S wrapAndCopyInto(S sink, Iterator<P_IN> iterator); abstract <P_IN> void copyInto(SelfSink<P_IN> wrappedSink, Iterator<P_IN> iterator); abstract <P_IN> SelfSink<P_IN> wrapSink(SelfSink<P_OUT> sink); }
package com.simple.boot.java_skill.selfλ; import java.util.Iterator; import java.util.Objects; import java.util.function.BiConsumer; import java.util.function.Supplier; /** * 尾部管道工厂模式 */ public class SelfReduceOpsFactory { // 生成尾部管道 public static <T, I> SelfTerminalOp<T, I> makeRef(SelfCollector<? super T, I> collector) { // 此例子是(Supplier<List<T>>) ArrayList::new Supplier<I> supplier = Objects.requireNonNull(collector).supplier(); // 此例子是List::add BiConsumer<I, ? super T> accumulator = collector.accumulator(); // 定义了ReducingSink的职责 class ReducingSink extends SelfBox<I> implements SelfTerminalSink<T, I> { @Override public void begin(long size) { // state = ArrayList::new = 初始化的空集合 state = supplier.get(); } @Override public void accept(T t) { // 向集合state中添加元素t accumulator.accept(state, t); } } // 生成ReduceOp（尾部管道接口的实现类），定义尾部管道的职责（并由ReducingSink执行该职责） return new SelfReduceOp<T, I, ReducingSink>() { // ReducingSink @Override public ReducingSink makeSink() { return new ReducingSink(); } }; } /** * 结果集 */ private static abstract class SelfBox<U> { U state; SelfBox() { } public U get() { return state; } } /** * 尾部管道 */ private static abstract class SelfReduceOp<T, R, S extends SelfTerminalSink<T, R>> implements SelfTerminalOp<T, R> { SelfReduceOp() { } // 生成尾部管道的sink，定义为抽象方法，终结操作终结结果有多种 public abstract S makeSink(); /** * 顺序评估管道 */ @Override public <P_IN> R evaluateSequential(SelfPipelineHelper<T> helper, Iterator<P_IN> iterator) { // 生成尾部管道的sink S reducingSink = makeSink(); // 管道包装sink：从ReducingSink（4）开始，按照3,4；2,3；1,2的顺序构建sink链，按照1,2,3,4的顺序执行流转，由4收集最终结果 S wrappedReducingSink = helper.wrapAndCopyInto(reducingSink, iterator); // 返回ReducingSink持有和可以supplier的集合 return wrappedReducingSink.get(); } } }
package com.simple.boot.java_skill.selfλ; import java.util.function.Consumer; /** * 下沉：一种Consumer函数式接口，执行指定动作 */ public interface SelfSink<T> extends Consumer<T> { default void begin(long size) { } default void end() { } /** * sink链 */ abstract class Chain<T, E_OUT> implements SelfSink<T> { // 下个sink protected final SelfSink<? super E_OUT> downstream; public Chain(SelfSink<? super E_OUT> downstream) { // 向下的单向链条 this.downstream = downstream; } // 本例：单向链条传递到最后一个ReducingSink，初始化结果集合 @Override public void begin(long size) { downstream.begin(size); } } }
package com.simple.boot.java_skill.selfλ; import java.util.function.Function; import java.util.function.Predicate; public interface SelfStream<T> { SelfStream<T> filter(Predicate<? super T> predicate); <R> SelfStream<R> map(Function<? super T, ? extends R> mapper); <R, A> R collect(SelfCollector<? super T, A> collector); }
package com.simple.boot.java_skill.selfλ; import java.util.Iterator; public interface SelfTerminalOp<E_IN, R> { <P_IN> R evaluateSequential(SelfPipelineHelper<E_IN> helper, Iterator<P_IN> iterator); }
package com.simple.boot.java_skill.selfλ; import java.util.function.Supplier; /** * 尾部管道的sink */ public interface SelfTerminalSink<T, R> extends SelfSink<T>, Supplier<R> { }
