Java 中的数据流和函数式编程

学习如何使用 Java 8 中的流 API 和函数式编程结构。

当 Java SE 8（又名核心 Java 8）在 2014 年被推出时，它引入了一些更改，从根本上影响了用它进行的编程。这些更改中有两个紧密相连的部分：流 API 和函数式编程构造。本文使用代码示例，从基础到高级特性，介绍每一个部分并说明它们之间的相互做用。

基础特性

流 API 是在数据序列中迭代元素的简洁而高级的方法。包 java.util.stream 和 java.util.function 包含了用于流 API 和相关函数式编程构造的新库。固然，代码示例赛过千言万语。

下面的代码段用大约 2,000 个随机整数值填充了一个 List：

Random rand = new Random2();
List<Integer> list = new ArrayList<Integer>();           // 空 list
for (int i = 0; i < 2048; i++) list.add(rand.nextInt()); // 填充它
复制代码

另外用一个 for 循环可用于遍历填充列表，以将偶数值收集到另外一个列表中。

流 API 提供了一种更简洁的方法来执行此操做：

List <Integer> evens = list
    .stream()                      // 流化 list
    .filter(n -> (n & 0x1) == 0)   // 过滤出奇数值
    .collect(Collectors.toList()); // 收集偶数值
复制代码

这个例子有三个来自流 API 的函数：

• stream 函数能够将集合转换为流，而流是一个每次可访问一个值的传送带。流化是惰性的（所以也是高效的），由于值是根据须要产生的，而不是一次性产生的。
• filter 函数肯定哪些流的值（若是有的话）经过了处理管道中的下一个阶段，即 collect 阶段。filter 函数是 高阶的higher-order，由于它的参数是一个函数 —— 在这个例子中是一个 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 宏操做由两个微操做构成。首先，将数据分散（映射mapped）到各个工做程序中，而后将单独的结果收集在一块儿 —— 也可能收集统计起来成为一个值，即归约reduction。归约能够采用不一样的形式，如如下示例所示。

下面 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 语法鼓励编写纯函数pure function，即函数的返回值仅取决于传入的参数（若是有）；纯函数没有反作用，例如更新一个类中的 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: 3322
The 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); // 10
tripled.applyAsInt(arg); // 15
squared.applyAsInt(arg); // 25
复制代码

如下是一些函数组合的样例：

int arg = 5;
doubled.compose(squared).applyAsInt(arg); // 5 求 2 次方后乘 2：50
tripled.compose(doubled).applyAsInt(arg); // 5 乘 2 后再乘 3：30
doubled.andThen(squared).applyAsInt(arg); // 5 乘 2 后求 2 次方：100
squared.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 的名字。

Fred
Wilma
Peebles
Dino
Baby Puss
复制代码

该示例对数据结构的微妙转换仅用几行代码便可完成，从而突出了能够将 lambda，方法引用或构造器引用做为参数的各类高阶函数的功能。

柯里化Currying

柯里化函数是指减小函数执行任何工做所需的显式参数的数量（一般减小到一个）。（该术语是为了记念逻辑学家 Haskell Curry。）通常来讲，函数的参数越少，调用起来就越容易，也更健壮。（回想一下一些须要半打左右参数的噩梦般的函数！）所以，应将柯里化视为简化函数调用的一种尝试。java.util.function 包中的接口类型适合于柯里化，如如下示例所示。

引用的 IntBinaryOperator 接口类型是为函数接受两个整型参数，并返回一个整型值：

IntBinaryOperator mult2 = (n1, n2) -> n1 * n2;
mult2.applyAsInt(10, 20); // 200
mult2.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 * 20
curriedMult2.applyAsInt(80); // 800 = 10 * 80
复制代码

缓存的值能够随意更改：

curriedMult2 = curriedMult2Maker.apply(50); // 缓存 50
curriedMult2.applyAsInt(101);               // 5050 = 101 * 50
复制代码

固然，能够经过这种方式建立多个已柯里化版本的 mult2，每一个版本都有一个 IntUnaryOperator。

柯里化充分利用了 lambda 的强大功能：能够很容易地编写 lambda 表达式来返回须要的任何类型的值，包括另外一个 lambda。

总结

Java 仍然是基于类的面向对象的编程语言。可是，借助流 API 及其支持的函数式构造，Java 向函数式语言（例如 Lisp）迈出了决定性的（同时也是受欢迎的）一步。结果是 Java 更适合处理现代编程中常见的海量数据流。在函数式方向上的这一步还使以在前面的代码示例中突出显示的管道的方式编写清晰简洁的 Java 代码更加容易：

dataStream
   .parallelStream() // 多线程以提升效率
   .filter(...)      // 阶段 1
   .map(...)         // 阶段 2
   .filter(...)      // 阶段 3
   ...
   .collect(...);    // 或者，也能够进行归约：阶段 N
复制代码

自动多线程，以 parallel 和 parallelStream 调用为例，创建在 Java 的 fork/join 框架上，该框架支持 任务窃取task stealing 以提升效率。假设 parallelStream 调用后面的线程池由八个线程组成，而且 dataStream 被八种方式分区。某个线程（例如，T1）可能比另外一个线程（例如，T7）工做更快，这意味着应该将 T7 的某些任务移到 T1 的工做队列中。这会在运行时自动发生。

在这个简单的多线程世界中，程序员的主要职责是编写线程安全函数，这些函数做为参数传递给在流 API 中占主导地位的高阶函数。尤为是 lambda 鼓励编写纯函数（所以是线程安全的）函数。

---

via: opensource.com/article/20/…

做者：Marty Kalin 选题：lujun9972 译者：laingke 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出