[三]java8 函数式编程Stream 概念深入理解 Stream 运行原理 Stream设计思路

表格内容来自https://docs.oracle.com/javase/8/docs/api/   Package java.util.stream  一节部分原文内容的翻译

支持顺序和并行聚合操作的一组元素序列除了Stream 还有专门为原始类型特殊化的IntStream、LongStream和double Stream  所有这些都被称为“流” 集合和流，虽然表面上有一些相似性，但有不同的设计目的 集合主要关注的是对其元素的有效管理和访问 相比之下，流并没有提供直接访问或操纵其元素的方法，而是关注于声明性地描述它们的源和计算操作，这些操作将在该源上进行聚合。 但是，如果所提供的流操作没有提供所需的功能，那么 BaseStream.iterator() 和 BaseStream.spliterator() 操作可以用来执行受控的遍历   示例: widgets 是 Collection<Widget> int sum = widgets.stream() .filter(w -> w.getColor() == RED) .mapToInt(w -> w.getWeight()) .sum();   像上面的“widgets”示例一样，流管道可以看作是在流的数据源上进行的查询。   除非源代码是为并发修改而显式设计的（例如ConcurrentHashMap），否则在查询时 修改流的源 可能导致不可预测或错误的行为。   大多数流操作都接受描述用户指定行为的参数，比如在上面的例子中传递给mapToInt的lambda表达式w-w.getweight（）。 为了保持正确的行为，这些行为参数：         必须是非干扰（也就是它们不修改流源）;         在大多数情况下，必须是无状态的（它们的结果不应该依赖于任何在流水线执行过程中可能发生变化的状态） 这些参数通常是函数接口的实例，例如Function，一般是lambda表达式或方法引用。除非另有说明，这些参数必须是非空的。   一个流应该只运行一次（调用中间操作或结束操作）。这就排除了比如“forked”流，在这些流中，相同的源提供两个或更多的管道，或者同一流的多个遍历。 一个流实现可能会抛出IllegalStateException 异常，如果它检测到流正在被重用。 然而，由于某些流操作可能返回它们的接收者而不是一个新的stream对象，所以并不能在所有情况下都检测到重用。   Streams有一个BaseStream.close（）方法并实现AutoCloseable，但是几乎所有的stream实例在使用后实际上并不需要关闭。 通常，只有源是IO通道的流（比Files.lines(Path,Charset)）将需要关闭。 大多数流都是由集合、数组或生成函数支持的，这些功能不需要特殊的资源管理。（如果流确实需要关闭，它可以在try-with-resources语句中声明为资源。）   流管道可以按顺序或并行执行 ,这种执行模式是流的属性。 流的类型是创建初始时选择通过顺序或并行操作执行来决定的。（例如，Collections.stream（）创建了一个顺序流，而Collection.parallelStream（）创建了一个并行的流。） 这种执行模式的选择可以由BaseStream.sequential() 或BaseStream.parallel()方法修改，并且可以使用BaseStream.isParallel() 方法查询。

集合是对一组特定类型的元素值序列提供的接口  是数据结构,提供了元素的存取 流也是对一组特定类型元素值序列提供的接口,在于计算,提供了对元素序列的操作计算方式 比如 filter map等

可以把流当做一个高级的迭代器Iterator ,内部有它自身运行逻辑的迭代器 你只需要告诉他你想要做什么,他自己就会自动的去迭代筛选组织你想要的数据

Stream.of( )      Stream类静态方法      转换XXX为Stream

Collection stream   集合转换为Stream 特   别   注   意:这是一个default方法,也就意味着如果没有特别处理,所有Collection子类都具有

Arrays.stream();     数组转换为Stream

Stream.iterate   Stream类静态方法迭代器的形式，创建一个数据流

Stream.generate

BaseStream规定了流的基本接口 Stream中定义了map、filter、flatmap等用户关注的常用操作； Int~ Long~ Double~是针对于基本类型的特化 方法与Stream中大致对应,当然也有一些差别 BaseStream Stream IntStream LongStream DoubleStream 组建了Java的流体系根基 他们都只是接口

PipelineHelper主要用于Stream执行过程中相关结构的构建ReferencePipeline  和 AbstractPipeline 完成了Stream的主要实现AbstractPipeline类实现了所有的 Stream的中间操作和最终操作[Int | Long | Double] pipeline 同理类似ReferencePipeline只不过是针对基本类型

Head、StatelessOp、StatefulOp为ReferencePipeline中的内部类[Int | Long | Double]Pipeline 内部也都是定义了这三个内部类

你会发现流的生成转换创建都是使用StreamSupport StreamSupport 是用于创建和操纵Stream的低级工具方法 除了构造方法,每个方法都是返回他们对应的Head ReferencePipeline.Head / DoublePipeline.Head / IntPipeline.Head /  LongPipeline.Head

数据源

说白了也就是上面说到过的Head  StatefulOp  StatelessOp  他们本身也是AbstractPipeline类型的

private final AbstractPipeline sourceStage;  //反向链接管道链的head,也就是说每个管道节点都有一个头 private final AbstractPipeline previousStage;//指向上一个 private AbstractPipeline nextStage;//指向下一个 赤裸裸的双向链表

Stream中将操作抽象化为stage 每个stage 也就是一个AbstractPipeline 每个stage 相当于一个双向链表的节点  ,每个节点都保存Head然后保存着上一个和下一个 这个双向链表就构成了整个流水线 (上面的图看起来next一直是null 是在每个处理后的this里面的previousStage里面 上一个的next是当前)

Stream体系是一组接口家族,AbstractPipeline 是接口的实现,PipelineHelper 是管道的辅助类,StreamSupport是流的低级工具类   使用stage来抽象流水线上的每个操作 其实每个stage就是一个stream 也就是AbstractPipeline几个子类的  内部子类  Head StatelessOp statefulOp StreamSupport用于创建生成Stream 对应的是Head类 其他的中间操作分为有状态和无状态的,中间操作通过方法比如 filter map 等返回的是StatelessOp  或者 statefulOp  多个stage组合称为双向链表的形式 从而成了整个流水线   有了流水线,相邻两个操作阶段之间如何协调运算? 于是又有了sink的概念,又来协调相邻的stage之间计算运行 他的模式是begin  accept end 还有短路标记 他的accept就是封装了回调方法   所以说每个操作stage, StatelessOp  或者 statefulOp中又封装了Sink 通过AbstractPipeline提供的opWrapSink方法可以获取这个sink 调用这个sink的accept方法就可以调用当前操作的方法   那么如何串联起来呢?关键点在于opWrapSink方法 ,他接收一个Sink作为参数 在调用accept方法中  可以调用这个入参sink的accept方法 这样子从当前就能调用下一个,也就是说有了推动的动作 那么只需要找到开始,每个处理了之后都推动下一个,就顺序完成了所欲的操作了   注意上面说的操作都是中间操作,中间操作才会产生操作阶段  终端操作不会增加stage的个数了

中间操作

filter() flatMap() limit() map()  concat() distinct() peek() skip() sorted() parallel() sequential() unordered()  flatMapTo[Double | Int | Long]  mapTo[ Double | Int | Long ]

流到流之间的转换filter(过滤), map(映射转换), mapTo[Int|Long|Double] (到基本类型流的转换),flatMap(流展开合并)，flatMapTo[Int|Long|Double],sorted(排序)，distinct(不重复值)，peek(执行某种操作，流不变，可用于调试)，limit(限制到指定元素数量), skip(跳过若干元素)

filter 条件筛选   boolean test(T t);

map   数据转换    R apply(T t); 新的值替换Stream中的值mapTo[Int | Long | Double] 类似

flatMap  R apply(T t); 同map但是是多个流转换为一个流 返回值限定为Stream其他flatMapTo[Int | Long | Double] 类似

生成流 iterate（） public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)

生成流 generate() public static<T> Stream<T> generate(Supplier<T> s)

一个归约操作（也称为折叠）接受一系列的输入元素，并通过重复应用组合操作将它们组合成一个简单的结果 例如查找一组数字的总和或最大值，或者将元素累积到一个列表中。 流的类中有多种形式的通用归约操作，称为reduce（）和collect（），以及多个专门化的简化形式，如sum（）、max（）或count（）。 当然，这样的操作可以很容易地实现为简单的顺序循环，如下所示： int sum = 0; for (int x : numbers) { sum += x; }     然而，我们有充分的理由倾向于减少操作，而不是像上面这样的累加运算。 它不仅是一个“更抽象的”——它在流上作为一个整体而不是单独的元素来运行——而且一个适当构造的reduce操作本质上是可并行的，只要用于处理元素的函数（s）是结合的和无状态的。举个例子，给定一个数字流，我们想要找到和，我们可以写：     int sum = numbers.stream().reduce(0, (x,y) -> x+y); 或者     int sum = numbers.stream().reduce(0, Integer::sum); 这些归约操作几乎不需要修改就可以并行运行     int sum = numbers.parallelStream().reduce(0, Integer::sum);   如果一个操作符或函数 op  满足    (a op b) op c == a op (b op c) ,那么他是结合的 结合性对于并行结算非常重要 比如      a op b op c op d == (a op b) op (c op d)     就可以并行计算  (a op b)    (c op d)   然后再处理他们

Optional<T> reduce(BinaryOperator<T> accumulator) 参数accumulator:  累计计算器——结合两个值的结合性、非干扰、无状态函数 因为没有初始值 所以返回值为 Optional<T> 计算1+2+3+4+5   相当于 boolean foundAny = false; T result = null; for (T element : this stream) { if (!foundAny) { foundAny = true; result = element; } else result = accumulator.apply(result, element); } return foundAny ? Optional.of(result) : Optional.empty();     如果不进入循环,那么foundAny就是false 直接返回 否则第一次循环给result赋值,此后foundAny 为true  result作为一个操作数调用accumulator.apply()   BinaryOperator 意味着两个操作数一个结果数 类型一样 这可不仅仅用于累加 还可以用来合并字符串 多种形式