Int Double Long 设置特定的stream类型， 提高性能，增加特定的函数

无存储。stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。

为函数式编程而生。对stream的任何修改都不会修改背后的数据源，比如对stream执行过滤操作并不会删除被过滤的元素，而是会产生一个不包含被过滤元素的新stream。

惰式执行。stream上的操作并不会立即执行，只有等到用户真正需要结果的时候才会执行。

可消费性。stream只能被“消费”一次，一旦遍历过就会失效，就像容器的迭代器那样，想要再次遍历必须重新生成。

对stream的操作分为为两类，中间操作(intermediate operations)和结束操作(terminal operations)，二者特点是：

中间操作总是会惰式执行，调用中间操作只会生成一个标记了该操作的新stream，仅此而已。

结束操作会触发实际计算，计算发生时会把所有中间操作积攒的操作以pipeline的方式执行，这样可以减少迭代次数。计算完成之后stream就会失效。

操作类型接口方法

中间操作concat() distinct() filter() flatMap() limit() map() peek()

skip() sorted() parallel() sequential() unordered()

结束操作allMatch() anyMatch() collect() count() findAny() findFirst()

forEach() forEachOrdered() max() min() noneMatch() reduce() toArray()

区分中间操作和结束操作最简单的方法，就是看方法的返回值，返回值为stream的大都是中间操作，否则是结束操作。

stream跟函数接口关系非常紧密，没有函数接口stream就无法工作。回顾一下：函数接口是指内部只有一个抽象方法的接口。通常函数接口出现的地方都可以使用Lambda表达式，所以不必记忆函数接口的名字。

几个没用过的

collect

如果你发现某个功能在Stream接口中没找到，十有八九可以通过collect()方法实现。collect()是Stream接口方法中最灵活的一个，学会它才算真正入门Java函数式编程

//将Stream转换成容器或MapStreamstream=Stream.of("I","love","you","too");Listlist=stream.collect(Collectors.toList());//(1)//Set set = stream.collect(Collectors.toSet()); // (2)//Map map = stream.collect(Collectors.toMap(Function.identity(), String::length)); // (3)

Function.identity()是干什么的？

String::length是什么意思？

Collectors是个什么东西？

Function是一个接口，那么Function.identity()是什么意思呢？这要从两方面解释：

Java 8允许在接口中加入具体方法。接口中的具体方法有两种，default方法和static方法，identity()就是Function接口的一个静态方法。

Function.identity()返回一个输出跟输入一样的Lambda表达式对象，等价于形如t -> t形式的Lambda表达式。

方法引用

String::length的语法形式叫做方法引用（method references），这种语法用来替代某些特定形式Lambda表达式。如果Lambda表达式的全部内容就是调用一个已有的方法，那么可以用方法引用来替代Lambda表达式。方法引用可以细分为四类：

方法引用类别举例

引用静态方法Integer::sum

引用某个对象的方法list::add

引用某个类的方法String::length

引用构造方法HashMap::new

收集器

收集器（Collector）是为Stream.collect()方法量身打造的工具接口（类）。考虑一下将一个Stream转换成一个容器（或者Map）需要做哪些工作？

目标容器是什么？

新元素如何添加到容器中？

多个部分结果如何合并成一个

结合以上分析，collect()方法定义为 R collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner)，三个参数依次对应上述三条分析。不过每次调用collect()都要传入这三个参数太麻烦，收集器Collector就是对这三个参数的简单封装,所以collect()的另一定义为 R collect(Collector collector)

//使用toCollection()指定规约容器的类型ArrayListarrayList=stream.collect(Collectors.toCollection(ArrayList::new));//(3)HashSethashSet=stream.collect(Collectors.toCollection(HashSet::new));//(4)

前面已经说过Stream背后依赖于某种数据源，数据源可以是数组、容器等，但不能是Map。反过来从Stream生成Map是可以的，但我们要想清楚Map的key和value分别代表什么，根本原因是我们要想清楚要干什么。通常在三种情况下collect()的结果会是Map：

使用Collectors.toMap()生成的收集器，用户需要指定如何生成Map的key和value。

使用Collectors.partitioningBy()生成的收集器，对元素进行二分区操作时用到。

使用Collectors.groupingBy()生成的收集器，对元素做group操作时用到。

情况2：使用partitioningBy()生成的收集器，这种情况适用于将Stream中的元素依据某个二值逻辑（满足条件，或不满足）分成互补相交的两部分，比如男女性别、成绩及格与否等。下列代码展示将学生分成成绩及格或不及格的两部分。

//Partition students into passing and failingMap>passingFailing=students.stream()        .collect(Collectors.partitioningBy(s->s.getGrade()>=PASS_THRESHOLD));

情况3：使用groupingBy()生成的收集器，这是比较灵活的一种情况。跟SQL中的group by语句类似，这里的groupingBy()也是按照某个属性对数据进行分组，属性相同的元素会被对应到Map的同一个key上。下列代码展示将员工按照部门进行分组：

//Group employees by department

Map>byDept=employees.stream()

.collect(Collectors.groupingBy(Employee::getDepartment));

以上只是分组的最基本用法，有些时候仅仅分组是不够的。在SQL中使用group by是为了协助其他查询，比如1. 先将员工按照部门分组，2. 然后统计每个部门员工的人数。Java类库设计者也考虑到了这种情况，增强版的groupingBy()能够满足这种需求。增强版的groupingBy()允许我们对元素分组之后再执行某种运算，比如求和、计数、平均值、类型转换等。这种先将元素分组的收集器叫做上游收集器，之后执行其他运算的收集器叫做下游收集器(downstream Collector)。

//使用下游收集器统计每个部门的人数MaptotalByDept=employees.stream()                    .collect(Collectors.groupingBy(Employee::getDepartment,Collectors.counting()));//下游收集器

上面代码的逻辑是不是越看越像SQL？高度非结构化。还有更狠的，下游收集器还可以包含更下游的收集器，这绝不是为了炫技而增加的把戏，而是实际场景需要。考虑将员工按照部门分组的场景，如果我们想得到每个员工的名字（字符串），而不是一个个Employee对象，可通过如下方式做到：

//按照部门对员工分布组，并只保留员工的名字Map>byDept=employees.stream()                .collect(Collectors.groupingBy(Employee::getDepartment,Collectors.mapping(Employee::getName,//下游收集器Collectors.toList())));//更下游的收集器

字符串拼接时使用Collectors.joining()生成的收集器，从此告别for循环。Collectors.joining()方法有三种重写形式，分别对应三种不同的拼接方式

//使用Collectors.joining()拼接字符串Streamstream=Stream.of("I","love","you");//String joined = stream.collect(Collectors.joining());// "Iloveyou"//String joined = stream.collect(Collectors.joining(","));// "I,love,you"Stringjoined=stream.collect(Collectors.joining(",","{","}"));//"{I,love,you}"

除了可以使用Collectors工具类已经封装好的收集器，我们还可以自定义收集器，或者直接调用collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner)方法，收集任何形式你想要的信息。不过Collectors工具类应该能满足我们的绝大部分需求，手动实现之间请先看看文档。

forEachOrdered

reduce

reduce操作可以实现从一组元素中生成一个值，sum()、max()、min()、count()等都是reduce操作，将他们单独设为函数只是因为常用。reduce()的方法定义有三种重写形式：

Optional reduce(BinaryOperator accumulator)

T reduce(T identity, BinaryOperator accumulator)

U reduce(U identity, BiFunction accumulator, BinaryOperator combiner)

虽然函数定义越来越长，但语义不曾改变，多的参数只是为了指明初始值（参数identity），或者是指定并行执行时多个部分结果的合并方式（参数combiner）。reduce()最常用的场景就是从一堆值中生成一个值

//求单词长度之和

Streamstream=Stream.of("I","love","you","too");

IntegerlengthSum=stream.reduce(0,//初始值　// (1)

(sum, str)->sum+str.length(),//累加器 // (2)

(a, b)->a+b);//部分和拼接器，并行执行时才会用到 // (3)

//int lengthSum = stream.mapToInt(str -> str.length()).sum();

System.out.println(lengthSum);

noneMatch

sequential

unordered

peek

skip

limit

PipeLine 原理

Stream操作分类

中间操作(Intermediate operations)无状态(Stateless)unordered() filter() map() mapToInt() mapToLong() mapToDouble() flatMap() flatMapToInt() flatMapToLong() flatMapToDouble() peek()

有状态(Stateful)distinct() sorted() sorted() limit() skip()

结束操作(Terminal operations)非短路操作forEach() forEachOrdered() toArray() reduce() collect() max() min() count()

短路操作(short-circuiting)anyMatch() allMatch() noneMatch() findFirst() findAny()

Stream上的所有操作分为两类：中间操作和结束操作，中间操作只是一种标记，只有结束操作才会触发实际计算。中间操作又可以分为无状态的(Stateless)和有状态的(Stateful)，无状态中间操作是指元素的处理不受前面元素的影响，而有状态的中间操作必须等到所有元素处理之后才知道最终结果，比如排序是有状态操作，在读取所有元素之前并不能确定排序结果；结束操作又可以分为短路操作和非短路操作，短路操作是指不用处理全部元素就可以返回结果，比如找到第一个满足条件的元素。之所以要进行如此精细的划分，是因为底层对每一种情况的处理方式不同。

pipeline 支持：

应该采用某种方式记录用户每一步的操作，当用户调用结束操作时将之前记录的操作叠加到一起在一次迭代中全部执行掉。沿着这个思路，有几个问题需要解决：

用户的操作如何记录？

操作如何叠加？

叠加之后的操作如何执行？

执行后的结果（如果有）在哪里？

注意这里使用的是“操作(operation)”一词，指的是“Stream中间操作”的操作，很多Stream操作会需要一个回调函数（Lambda表达式），因此一个完整的操作是<数据来源，操作，回调函数>构成的三元组。Stream中使用Stage的概念来描述一个完整的操作，并用某种实例化后的PipelineHelper来代表Stage，将具有先后顺序的各个Stage连到一起，就构成了整个流水线。跟Stream相关类和接口的继承关系图示。

图中Head用于表示第一个Stage，即调用调用诸如Collection.stream()方法产生的Stage，很显然这个Stage里不包含任何操作；StatelessOp和StatefulOp分别表示无状态和有状态的Stage，对应于无状态和有状态的中间操作。

图中通过Collection.stream()方法得到Head也就是stage0，紧接着调用一系列的中间操作，不断产生新的Stream。这些Stream对象以双向链表的形式组织在一起，构成整个流水线，由于每个Stage都记录了前一个Stage和本次的操作以及回调函数，依靠这种结构就能建立起对数据源的所有操作。这就是Stream记录操作的方式。

要想让流水线起到应有的作用我们需要一种将所有操作叠加到一起的方案。你可能会觉得这很简单，只需要从流水线的head开始依次执行每一步的操作（包括回调函数）就行了。这听起来似乎是可行的，但是你忽略了前面的Stage并不知道后面Stage到底执行了哪种操作，以及回调函数是哪种形式。换句话说，只有当前Stage本身才知道该如何执行自己包含的动作。这就需要有某种协议来协调相邻Stage之间的调用关系

这种协议由Sink接口完成，Sink接口包含的方法如下表所示：

方法名作用

void begin(long size)开始遍历元素之前调用该方法，通知Sink做好准备。

void end()所有元素遍历完成之后调用，通知Sink没有更多的元素了。

boolean cancellationRequested()是否可以结束操作，可以让短路操作尽早结束。

void accept(T t)遍历元素时调用，接受一个待处理元素，并对元素进行处理。Stage把自己包含的操作和回调方法封装到该方法里，前一个Stage只需要调用当前Stage.accept(T t)方法就行了。

有了上面的协议，相邻Stage之间调用就很方便了，每个Stage都会将自己的操作封装到一个Sink里，前一个Stage只需调用后一个Stage的accept()方法即可，并不需要知道其内部是如何处理的。当然对于有状态的操作，Sink的begin()和end()方法也是必须实现的。比如Stream.sorted()是一个有状态的中间操作，其对应的Sink.begin()方法可能创建一个乘放结果的容器，而accept()方法负责将元素添加到该容器，最后end()负责对容器进行排序。对于短路操作，Sink.cancellationRequested()也是必须实现的，比如Stream.findFirst()是短路操作，只要找到一个元素，cancellationRequested()就应该返回true，以便调用者尽快结束查找。Sink的四个接口方法常常相互协作，共同完成计算任务。实际上Stream API内部实现的的本质，就是如何重载Sink的这四个接口方法。

有了Sink对操作的包装，Stage之间的调用问题就解决了，执行时只需要从流水线的head开始对数据源依次调用每个Stage对应的Sink.{begin(), accept(), cancellationRequested(), end()}方法就可以了。一种可能的Sink.accept()方法流程是这样的：

voidaccept(Uu){1.使用当前Sink包装的回调函数处理u2.将处理结果传递给流水线下游的Sink}

Sink接口的其他几个方法也是按照这种[处理->转发]的模型实现。下面我们结合具体例子看看Stream的中间操作是如何将自身的操作包装成Sink以及Sink是如何将处理结果转发给下一个Sink的。先看Stream.map()方法：

//Stream.map()，调用该方法将产生一个新的StreampublicfinalStreammap(Functionmapper) {...returnnewStatelessOp(this,StreamShape.REFERENCE,StreamOpFlag.NOT_SORTED|StreamOpFlag.NOT_DISTINCT) {@Override/*opWripSink()方法返回由回调函数包装而成Sink*/SinkopWrapSink(intflags,Sinkdownstream) {returnnewSink.ChainedReference(downstream) {@Overridepublicvoidaccept(P_OUTu) {Rr=mapper.apply(u);//1. 使用当前Sink包装的回调函数mapper处理udownstream.accept(r);//2. 将处理结果传递给流水线下游的Sink}            };        }    };}

上述代码看似复杂，其实逻辑很简单，就是将回调函数mapper包装到一个Sink当中。由于Stream.map()是一个无状态的中间操作，所以map()方法返回了一个StatelessOp内部类对象（一个新的Stream），调用这个新Stream的opWripSink()方法将得到一个包装了当前回调函数的Sink。

再来看一个复杂一点的例子。Stream.sorted()方法将对Stream中的元素进行排序，显然这是一个有状态的中间操作，因为读取所有元素之前是没法得到最终顺序的。抛开模板代码直接进入问题本质，sorted()方法是如何将操作封装成Sink的呢？sorted()一种可能封装的Sink代码如下：

//Stream.sort()方法用到的Sink实现classRefSortingSinkextendsAbstractRefSortingSink{privateArrayListlist;//存放用于排序的元素RefSortingSink(Sinkdownstream,Comparatorcomparator) {super(downstream, comparator);    }@Overridepublicvoidbegin(longsize) {...//创建一个存放排序元素的列表list=(size>=0)?newArrayList((int) size):newArrayList();    }@Overridepublicvoidend() {        list.sort(comparator);//只有元素全部接收之后才能开始排序downstream.begin(list.size());if(!cancellationWasRequested) {//下游Sink不包含短路操作list.forEach(downstream::accept);//2. 将处理结果传递给流水线下游的Sink}else{//下游Sink包含短路操作for(Tt:list) {//每次都调用cancellationRequested()询问是否可以结束处理。if(downstream.cancellationRequested())break;                downstream.accept(t);//2. 将处理结果传递给流水线下游的Sink}        }        downstream.end();        list=null;    }@Overridepublicvoidaccept(Tt) {        list.add(t);//1. 使用当前Sink包装动作处理t，只是简单的将元素添加到中间列表当中}}

上述代码完美的展现了Sink的四个接口方法是如何协同工作的：

首先beging()方法告诉Sink参与排序的元素个数，方便确定中间结果容器的的大小；

之后通过accept()方法将元素添加到中间结果当中，最终执行时调用者会不断调用该方法，直到遍历所有元素；

最后end()方法告诉Sink所有元素遍历完毕，启动排序步骤，排序完成后将结果传递给下游的Sink；

如果下游的Sink是短路操作，将结果传递给下游时不断询问下游cancellationRequested()是否可以结束处理。

Sink完美封装了Stream每一步操作，并给出了[处理->转发]的模式来叠加操作。这一连串的齿轮已经咬合，就差最后一步拨动齿轮启动执行。是什么启动这一连串的操作呢？也许你已经想到了启动的原始动力就是结束操作(Terminal Operation)，一旦调用某个结束操作，就会触发整个流水线的执行。

结束操作之后不能再有别的操作，所以结束操作不会创建新的流水线阶段(Stage)，直观的说就是流水线的链表不会在往后延伸了。结束操作会创建一个包装了自己操作的Sink，这也是流水线中最后一个Sink，这个Sink只需要处理数据而不需要将结果传递给下游的Sink（因为没有下游）。对于Sink的[处理->转发]模型，结束操作的Sink就是调用链的出口。

我们再来考察一下上游的Sink是如何找到下游Sink的。一种可选的方案是在PipelineHelper中设置一个Sink字段，在流水线中找到下游Stage并访问Sink字段即可。但Stream类库的设计者没有这么做，而是设置了一个Sink AbstractPipeline.opWrapSink(int flags, Sink downstream)方法来得到Sink，该方法的作用是返回一个新的包含了当前Stage代表的操作以及能够将结果传递给downstream的Sink对象。为什么要产生一个新对象而不是返回一个Sink字段？这是因为使用opWrapSink()可以将当前操作与下游Sink（上文中的downstream参数）结合成新Sink。试想只要从流水线的最后一个Stage开始，不断调用上一个Stage的opWrapSink()方法直到最开始（不包括stage0，因为stage0代表数据源，不包含操作），就可以得到一个代表了流水线上所有操作的Sink，用代码表示就是这样：

//AbstractPipeline.wrapSink()//从下游向上游不断包装Sink。如果最初传入的sink代表结束操作，//函数返回时就可以得到一个代表了流水线上所有操作的Sink。finalSinkwrapSink(Sinksink) {...for(AbstractPipelinep=AbstractPipeline.this; p.depth>0; p=p.previousStage) {        sink=p.opWrapSink(p.previousStage.combinedFlags, sink);    }return(Sink) sink;}

现在流水线上从开始到结束的所有的操作都被包装到了一个Sink里，执行这个Sink就相当于执行整个流水线，执行Sink的代码如下：

//AbstractPipeline.copyInto(), 对spliterator代表的数据执行wrappedSink代表的操作。finalvoidcopyInto(SinkwrappedSink,Spliteratorspliterator) {...if(!StreamOpFlag.SHORT_CIRCUIT.isKnown(getStreamAndOpFlags())) {        wrappedSink.begin(spliterator.getExactSizeIfKnown());//通知开始遍历spliterator.forEachRemaining(wrappedSink);//迭代wrappedSink.end();//通知遍历结束}...}

最后一个问题是流水线上所有操作都执行后，用户所需要的结果（如果有）在哪里？首先要说明的是不是所有的Stream结束操作都需要返回结果，有些操作只是为了使用其副作用(Side-effects)，比如使用Stream.forEach()方法将结果打印出来就是常见的使用副作用的场景（事实上，除了打印之外其他场景都应避免使用副作用），对于真正需要返回结果的结束操作结果存在哪里呢？

特别说明：副作用不应该被滥用，也许你会觉得在Stream.forEach()里进行元素收集是个不错的选择，就像下面代码中那样，但遗憾的是这样使用的正确性和效率都无法保证，因为Stream可能会并行执行。大多数使用副作用的地方都可以使用归约操作更安全和有效的完成。

//错误的收集方式ArrayListresults=newArrayList<>();stream.filter(s->pattern.matcher(s).matches())      .forEach(s->results.add(s));//Unnecessary use of side-effects!//正确的收集方式Listresults=stream.filter(s->pattern.matcher(s).matches())            .collect(Collectors.toList());//No side-effects!

回到流水线执行结果的问题上来，需要返回结果的流水线结果存在哪里呢？这要分不同的情况讨论，下表给出了各种有返回结果的Stream结束操作。

返回类型对应的结束操作

booleananyMatch() allMatch() noneMatch()

OptionalfindFirst() findAny()

归约结果reduce() collect()

数组toArray()

对于表中返回boolean或者Optional的操作（Optional是存放 一个 值的容器）的操作，由于值返回一个值，只需要在对应的Sink中记录这个值，等到执行结束时返回就可以了。

对于归约操作，最终结果放在用户调用时指定的容器中（容器类型通过收集器指定）。collect(), reduce(), max(), min()都是归约操作，虽然max()和min()也是返回一个Optional，但事实上底层是通过调用reduce()方法实现的。

对于返回是数组的情况，毫无疑问的结果会放在数组当中。这么说当然是对的，但在最终返回数组之前，结果其实是存储在一种叫做Node的数据结构中的。Node是一种多叉树结构，元素存储在树的叶子当中，并且一个叶子节点可以存放多个元素。这样做是为了并行执行方便。关于Node的具体结构，我们会在下一节探究Stream如何并行执行时给出详细说明。