基础特性流 api 是在数据序列中迭代元素的简洁而高级的方法。包 java.util.stream 和 java.util.function 包含了用于流 api 和相关函数式编程构造的新库。当然，代码示例胜过千言万语。
下面的代码段用大约 2,000 个随机整数值填充了一个 list：
random rand = new random2();list<integer> list = new arraylist<integer>();           // 空 listfor (int i = 0; i  (n & 0x1) == 0)   // 过滤出奇数值    .collect(collectors.tolist()); // 收集偶数值
这个例子有三个来自流 api 的函数：
stream 函数可以将集合转换为流，而流是一个每次可访问一个值的传送带。流化是惰性的（因此也是高效的），因为值是根据需要产生的，而不是一次性产生的。
filter 函数确定哪些流的值（如果有的话）通过了处理管道中的下一个阶段，即 collect 阶段。filter 函数是
，因为它的参数是一个函数 —— 在这个例子中是一个 lambda 表达式，它是一个未命名的函数，并且是 java 新的函数式编程结构的核心。
lambda 语法与传统的 java 完全不同：
n -> (n & 0x1) == 0
箭头（一个减号后面紧跟着一个大于号）将左边的参数列表与右边的函数体分隔开。参数 n 虽未明确类型，但也可以明确。在任何情况下，编译器都会发现 n 是个 integer。如果有多个参数，这些参数将被括在括号中，并用逗号分隔。
在本例中，函数体检查一个整数的最低位（最右）是否为零，这用来表示偶数。过滤器应返回一个布尔值。尽管可以，但该函数的主体中没有显式的 return。如果主体没有显式的 return，则主体的最后一个表达式即是返回值。在这个例子中，主体按照 lambda 编程的思想编写，由一个简单的布尔表达式 (n & 0x1) == 0 组成。
collect 函数将偶数值收集到引用为 evens 的列表中。如下例所示，collect 函数是线程安全的，因此，即使在多个线程之间共享了过滤操作，该函数也可以正常工作。
方便的功能和轻松实现多线程在生产环境中，数据流的源可能是文件或网络连接。为了学习流 api, java 提供了诸如 intstream 这样的类型，它可以用各种类型的元素生成流。这里有一个 intstream 的例子：
intstream                          // 整型流    .range(1, 2048)                // 生成此范围内的整型流    .parallel()                    // 为多个线程分区数据    .filter(i -> ((i & 0x1) > 0))  // 奇偶校验 - 只允许奇数通过    .foreach(system.out::println); // 打印每个值
intstream 类型包括一个 range 函数，该函数在指定的范围内生成一个整数值流，在本例中，以 1 为增量，从 1 递增到 2048。parallel 函数自动划分该工作到多个线程中，在各个线程中进行过滤和打印。（线程数通常与主机系统上的 cpu 数量匹配。）函数 foreach 参数是一个方法引用，在本例中是对封装在 system.out 中的 println 方法的引用，方法输出类型为 printstream。方法和构造器引用的语法将在稍后讨论。
由于具有多线程，因此整数值整体上以任意顺序打印，但在给定线程中是按顺序打印的。例如，如果线程 t1 打印 409 和 411，那么 t1 将按照顺序 409-411 打印，但是其它某个线程可能会预先打印 2045。parallel 调用后面的线程是并发执行的，因此它们的输出顺序是不确定的。
map/reduce 模式map/reduce 模式在处理大型数据集方面变得很流行。一个 map/reduce 宏操作由两个微操作构成。首先，将数据分散（）到各个工作程序中，然后将单独的结果收集在一起 —— 也可能收集统计起来成为一个值，即。归约可以采用不同的形式，如以下示例所示。
下面 number 类的实例用 even 或 odd 表示有奇偶校验的整数值：
public class number {    enum parity { even, odd }    private int value;    public number(int n) { setvalue(n); }    public void setvalue(int value) { this.value = value; }    public int getvalue() { return this.value; }    public parity getparity() {        return ((value & 0x1) == 0) ? parity.even : parity.odd;    }    public void dump() {        system.out.format(value: %2d (parity: %s)\n, getvalue(),                          (getparity() == parity.odd ? odd : even));    }}
下面的代码演示了用 number 流进行 map/reduce 的情形，从而表明流 api 不仅可以处理 int 和 float 等基本类型，还可以处理程序员自定义的类类型。
在下面的代码段中，使用了 parallelstream 而不是 stream 函数对随机整数值列表进行流化处理。与前面介绍的 parallel 函数一样，parallelstream 变体也可以自动执行多线程。
final int howmany = 200;random r = new random();number[] nums = new number[howmany];for (int i = 0; i < howmany; i++) nums[i] = new number(r.nextint(100));list<number> listofnums = arrays.aslist(nums);  // 将数组转化为 list integer sum4all = listofnums    .parallelstream()           // 自动执行多线程    .maptoint(number::getvalue) // 使用方法引用，而不是 lambda    .sum();                     // 将流值计算出和值system.out.println(the sum of the randomly generated values is:  + sum4all);
高阶的 maptoint 函数可以接受一个 lambda 作为参数，但在本例中，它接受一个方法引用，即 number::getvalue。getvalue 方法不需要参数，它返回给定的 number 实例的 int 值。语法并不复杂：类名 number 后跟一个双冒号和方法名。回想一下先前的例子 system.out::println，它在 system 类中的 static 属性 out 后面有一个双冒号。
方法引用 number::getvalue 可以用下面的 lambda 表达式替换。参数 n 是流中的 number 实例中的之一：
maptoint(n -> n.getvalue())
通常，lambda 表达式和方法引用是可互换的：如果像 maptoint  这样的高阶函数可以采用一种形式作为参数，那么这个函数也可以采用另一种形式。这两个函数式编程结构具有相同的目的 ——  对作为参数传入的数据执行一些自定义操作。在两者之间进行选择通常是为了方便。例如，lambda  可以在没有封装类的情况下编写，而方法则不能。我的习惯是使用 lambda，除非已经有了适当的封装方法。
当前示例末尾的 sum 函数通过结合来自 parallelstream 线程的部分和，以线程安全的方式进行归约。但是，程序员有责任确保在 parallelstream 调用引发的多线程过程中，程序员自己的函数调用（在本例中为 getvalue）是线程安全的。
最后一点值得强调。lambda 语法鼓励编写，即函数的返回值仅取决于传入的参数（如果有）；纯函数没有副作用，例如更新一个类中的 static 字段。因此，纯函数是线程安全的，并且如果传递给高阶函数的函数参数（例如 filter 和 map ）是纯函数，则流 api 效果最佳。
对于更细粒度的控制，有另一个流 api 函数，名为 reduce，可用于对 number 流中的值求和:
integer sum4allharder = listofnums    .parallelstream()                           // 多线程    .map(number::getvalue)                      // 每个 number 的值    .reduce(0, (sofar, next) -> sofar + next);  // 求和
此版本的 reduce 函数带有两个参数，第二个参数是一个函数：
第一个参数（在这种情况下为零）是特征值，该值用作求和操作的初始值，并且在求和过程中流结束时用作默认值。
第二个参数是累加器，在本例中，这个 lambda 表达式有两个参数：第一个参数（sofar）是正在运行的和，第二个参数（next）是来自流的下一个值。运行的和以及下一个值相加，然后更新累加器。请记住，由于开始时调用了 parallelstream，因此 map 和 reduce 函数现在都在多线程上下文中执行。
在到目前为止的示例中，流值被收集，然后被规约，但是，通常情况下，流 api 中的 collectors 可以累积值，而不需要将它们规约到单个值。正如下一个代码段所示，收集活动可以生成任意丰富的数据结构。该示例使用与前面示例相同的 listofnums：
map<number.parity, list<number>> nummap = listofnums    .parallelstream()    .collect(collectors.groupingby(number::getparity)); list<number> evens = nummap.get(number.parity.even);list<number> odds = nummap.get(number.parity.odd);
第一行中的 nummap 指的是一个 map，它的键是一个 number 奇偶校验位（odd 或 even），其值是一个具有指定奇偶校验位值的 number 实例的 list。同样，通过 parallelstream 调用进行多线程处理，然后 collect 调用（以线程安全的方式）将部分结果组装到 nummap 引用的 map 中。然后，在 nummap 上调用 get 方法两次，一次获取 evens，第二次获取 odds。
实用函数 dumplist 再次使用来自流 api 的高阶 foreach 函数：
private void dumplist(string msg, list<number> list) {    system.out.println(\n + msg);    list.stream().foreach(n -> n.dump()); // 或者使用 foreach(number::dump)}
这是示例运行中程序输出的一部分：
the sum of the randomly generated values is: 3322the sum again, using a different method:     3322 evens: value: 72 (parity: even)value: 54 (parity: even)...value: 92 (parity: even) odds: value: 35 (parity: odd)value: 37 (parity: odd)...value: 41 (parity: odd)
用于代码简化的函数式结构函数式结构（如方法引用和 lambda 表达式）非常适合在流 api 中使用。这些构造代表了 java 中对高阶函数的主要简化。即使在糟糕的过去，java 也通过 method 和 constructor 类型在技术上支持高阶函数，这些类型的实例可以作为参数传递给其它函数。由于其复杂性，这些类型在生产级 java 中很少使用。例如，调用 method 需要对象引用（如果方法是非静态的）或至少一个类标识符（如果方法是静态的）。然后，被调用的 method 的参数作为对象实例传递给它，如果没有发生多态（那会出现另一种复杂性！），则可能需要显式向下转换。相比之下，lambda 和方法引用很容易作为参数传递给其它函数。
但是，新的函数式结构在流 api 之外具有其它用途。考虑一个 java gui 程序，该程序带有一个供用户按下的按钮，例如，按下以获取当前时间。按钮按下的事件处理程序可能编写如下：
jbutton updatecurrenttime = new jbutton(update current time);updatecurrenttime.addactionlistener(new actionlistener() {    @override    public void actionperformed(actionevent e) {        currenttime.settext(new date().tostring());    }});
这个简短的代码段很难解释。关注第二行，其中方法 addactionlistener 的参数开始如下：
new actionlistener() {
这似乎是错误的，因为 actionlistener 是一个抽象接口，而抽象类型不能通过调用 new 实例化。但是，事实证明，还有其它一些实例被实例化了：一个实现此接口的未命名内部类。如果上面的代码封装在名为 oldjava 的类中，则该未命名的内部类将被编译为 oldjava$1.class。actionperformed 方法在这个未命名的内部类中被重写。
现在考虑使用新的函数式结构进行这个令人耳目一新的更改：
updatecurrenttime.addactionlistener(e -> currenttime.settext(new date().tostring()));
lambda 表达式中的参数 e 是一个 actionevent 实例，而 lambda 的主体是对按钮上的 settext 的简单调用。
函数式接口和函数组合到目前为止，使用的 lambda 已经写好了。但是，为了方便起见，我们可以像引用封装方法一样引用 lambda 表达式。以下一系列简短示例说明了这一点。
考虑以下接口定义：
@functionalinterface // 可选，通常省略interface binaryintop {    abstract int compute(int arg1, int arg2); // abstract 声明可以被删除}
注释 @functionalinterface 适用于声明唯一抽象方法的任何接口；在本例中，这个抽象接口是 compute。一些标准接口，（例如具有唯一声明方法 run 的 runnable 接口）同样符合这个要求。在此示例中，compute 是已声明的方法。该接口可用作引用声明中的目标类型：
binaryintop div = (arg1, arg2) -> arg1 / arg2;div.compute(12, 3); // 4
包 java.util.function 提供各种函数式接口。以下是一些示例。
下面的代码段介绍了参数化的 predicate 函数式接口。在此示例中，带有参数 string 的 predicate<string> 类型可以引用具有 string 参数的 lambda 表达式或诸如 isempty 之类的 string 方法。通常情况下，predicate 是一个返回布尔值的函数。
predicate<string> pred = string::isempty; // string 方法的 predicate 声明string[] strings = {one, two, , three, four};arrays.aslist(strings)   .stream()   .filter(pred)                  // 过滤掉非空字符串   .foreach(system.out::println); // 只打印空字符串
在字符串长度为零的情况下，isempty predicate 判定结果为 true。 因此，只有空字符串才能进入管道的 foreach 阶段。
下一段代码将演示如何将简单的 lambda 或方法引用组合成更丰富的 lambda 或方法引用。考虑这一系列对 intunaryoperator 类型的引用的赋值，它接受一个整型参数并返回一个整型值：
intunaryoperator doubled = n -> n * 2;intunaryoperator tripled = n -> n * 3;intunaryoperator squared = n -> n * n;
intunaryoperator 是一个 functionalinterface，其唯一声明的方法为 applyasint。现在可以单独使用或以各种组合形式使用这三个引用 doubled、tripled 和 squared：
int arg = 5;doubled.applyasint(arg); // 10tripled.applyasint(arg); // 15squared.applyasint(arg); // 25
以下是一些函数组合的样例：
int arg = 5;doubled.compose(squared).applyasint(arg); // 5 求 2 次方后乘 2：50tripled.compose(doubled).applyasint(arg); // 5 乘 2 后再乘 3：30doubled.andthen(squared).applyasint(arg); // 5 乘 2 后求 2 次方：100squared.andthen(tripled).applyasint(arg); // 5 求 2 次方后乘 3：75
函数组合可以直接使用 lambda 表达式实现，但是引用使代码更简洁。
构造器引用构造器引用是另一种函数式编程构造，而这些引用在比 lambda 和方法引用更微妙的上下文中非常有用。再一次重申，代码示例似乎是最好的解释方式。
考虑这个 pojo 类：
public class bedrocker { // 基岩的居民    private string name;    public bedrocker(string name) { this.name = name; }    public string getname() { return this.name; }    public void dump() { system.out.println(getname()); }}
该类只有一个构造函数，它需要一个 string 参数。给定一个名字数组，目标是生成一个 bedrocker 元素数组，每个名字代表一个元素。下面是使用了函数式结构的代码段：
string[] names = {fred, wilma, peebles, dino, baby puss}; stream<bedrocker> bedrockers = arrays.aslist(names).stream().map(bedrocker::new);bedrocker[] arraybr = bedrockers.toarray(bedrocker[]::new); arrays.aslist(arraybr).stream().foreach(bedrocker::dump);
在较高的层次上，这个代码段将名字转换为 bedrocker 数组元素。具体来说，代码如下所示。stream 接口（在包 java.util.stream 中）可以被参数化，而在本例中，生成了一个名为 bedrockers 的 bedrocker 流。
arrays.aslist 实用程序再次用于流化一个数组 names，然后将流的每一项传递给 map 函数，该函数的参数现在是构造器引用 bedrocker::new。这个构造器引用通过在每次调用时生成和初始化一个 bedrocker 实例来充当一个对象工厂。在第二行执行之后，名为 bedrockers 的流由五项 bedrocker 组成。
这个例子可以通过关注高阶 map 函数来进一步阐明。在通常情况下，一个映射将一个类型的值（例如，一个 int）转换为另一个相同类型的值（例如，一个整数的后继）:
map(n -> n + 1) // 将 n 映射到其后继
然而，在 bedrocker 这个例子中，转换更加戏剧化，因为一个类型的值（代表一个名字的 string）被映射到一个不同类型的值，在这个例子中，就是一个 bedrocker 实例，这个字符串就是它的名字。转换是通过一个构造器调用来完成的，它是由构造器引用来实现的：
map(bedrocker::new) // 将 string 映射到 bedrocker
传递给构造器的值是 names 数组中的其中一项。
此代码示例的第二行还演示了一个你目前已经非常熟悉的转换：先将数组先转换成 list，然后再转换成 stream：
stream<bedrocker> bedrockers = arrays.aslist(names).stream().map(bedrocker::new);
第三行则是另一种方式 —— 流 bedrockers 通过使用数组构造器引用 bedrocker[]::new 调用 toarray 方法:
bedrocker[ ] arraybr = bedrockers.toarray(bedrocker[]::new);
该构造器引用不会创建单个 bedrocker 实例，而是创建这些实例的整个数组：该构造器引用现在为 bedrocker[]:new，而不是 bedrocker::new。为了进行确认，将 arraybr 转换为 list，再次对其进行流式处理，以便可以使用 foreach 来打印 bedrocker 的名字。
fredwilmapeeblesdinobaby puss
该示例对数据结构的微妙转换仅用几行代码即可完成，从而突出了可以将 lambda，方法引用或构造器引用作为参数的各种高阶函数的功能。
柯里化函数是指减少函数执行任何工作所需的显式参数的数量（通常减少到一个）。（该术语是为了纪念逻辑学家 haskell  curry。）一般来说，函数的参数越少，调用起来就越容易，也更健壮。（回想一下一些需要半打左右参数的噩梦般的函数！）因此，应将柯里化视为简化函数调用的一种尝试。java.util.function 包中的接口类型适合于柯里化，如以下示例所示。
引用的 intbinaryoperator 接口类型是为函数接受两个整型参数，并返回一个整型值：
intbinaryoperator mult2 = (n1, n2) -> n1 * n2;mult2.applyasint(10, 20); // 200mult2.applyasint(10, 30); // 300
引用 mult2 强调了需要两个显式参数，在本例中是 10 和 20。
前面介绍的 intunaryoperator 比 intbinaryoperator 简单，因为前者只需要一个参数，而后者则需要两个参数。两者均返回整数值。因此，目标是将名为 mult2 的两个参数 intbinraryoperator 柯里化成一个单一的 intunaryoperator 版本 curriedmult2。
考虑 intfunction<r> 类型。此类型的函数采用整型参数，并返回类型为 r 的结果，该结果可以是另一个函数 —— 更准确地说，是 intbinaryoperator。让一个 lambda 返回另一个 lambda 很简单：
arg1 -> (arg2 -> arg1 * arg2) // 括号可以省略
完整的 lambda 以 arg1 开头，而该 lambda 的主体以及返回的值是另一个以 arg2 开头的 lambda。返回的 lambda 仅接受一个参数（arg2），但返回了两个数字的乘积（arg1 和 arg2）。下面的概述，再加上代码，应该可以更好地进行说明。
以下是如何柯里化 mult2 的概述：
类型为 intfunction<intunaryoperator> 的 lambda 被写入并调用，其整型值为 10。返回的 intunaryoperator 缓存了值 10，因此变成了已柯里化版本的 mult2，在本例中为 curriedmult2。
然后使用单个显式参数（例如，20）调用 curriedmult2 函数，该参数与缓存的参数（在本例中为 10）相乘以生成返回的乘积。。
这是代码的详细信息：
// 创建一个接受一个参数 n1 并返回一个单参数 n2 -> n1 * n2 的函数，该函数返回一个（n1 * n2 乘积的）整型数。intfunction<intunaryoperator> curriedmult2maker = n1 -> (n2 -> n1 * n2);
调用 curriedmult2maker 生成所需的 intunaryoperator 函数：
// 使用 curriedmult2maker 获取已柯里化版本的 mult2。// 参数 10 是上面的 lambda 的 n1。intunaryoperator curriedmult2 = curriedmult2maker2.apply(10);
值 10 现在缓存在 curriedmult2 函数中，以便 curriedmult2 调用中的显式整型参数乘以 10：
curriedmult2.applyasint(20); // 200 = 10 * 20curriedmult2.applyasint(80); // 800 = 10 * 80
缓存的值可以随意更改：
curriedmult2 = curriedmult2maker.apply(50); // 缓存 50curriedmult2.applyasint(101);               // 5050 = 101 * 50
当然，可以通过这种方式创建多个已柯里化版本的 mult2，每个版本都有一个 intunaryoperator。
柯里化充分利用了 lambda 的强大功能：可以很容易地编写 lambda 表达式来返回需要的任何类型的值，包括另一个 lambda。
以上就是java数据流和函数式编程如何实现的详细内容。