JAVA8函数式编程

开发类库的程序员使用Java 时，发现抽象级别还不够。处理大型数据集合就是个很好的例子，面对大型数据集合，Java 还欠缺高效的并行操作。开发者能够使用Java 8 编写复杂的集合处理算法，只需要简单修改一个方法，就能让代码在多核CPU 上高效运行。为了编写这类处理批量数据的并行类库，需要在语言层面上修改现有的Java：增加Lambda 表达式。

对于习惯了面向对象编程的开发者来说，抽象的概念并不陌生。面向对象编程是对数据进行抽象，而函数式编程是对行为进行抽象。现实世界中，数据和行为并存，程序也是如此，因此这两种编程方式我们都得学。

在写回调函数和事件处理程序时，程序员不必再纠缠于匿名内部类的冗繁和可读性，函数式编程让事件处理系统变得更加简单。能将函数方便地传递也让编写惰性代码变得容易，惰性代码在真正需要时才初始化变量的值。

每个人对函数式编程的理解不尽相同。但其核心是：在思考问题时，使用不可变值和函数，函数对一个值进行处理，映射成另一个值。

2.Lambda表达式

函数接口是只有一个抽象方法的接口，用作Lambda 表达式的类型。

2.6　要点回顾

Lambda 表达式是一个匿名方法，将行为像数据一样进行传递。

Lambda表达式的常见结构：BinaryOperator add = (x, y)→ x + y。

函数接口指仅具有单个抽象方法的接口，用来表示 Lambda表达式的类型。

3.流 -Stream

3.1 从外部迭代到内部迭代

惰性求值与及早求值:

判断一个操作是惰性求值还是及早求值很简单：只需看它的返回值。如果返回值是Stream，

那么是惰性求值；如果返回值是另一个值或为空，那么就是及早求值。使用这些操作的理

想方式就是形成一个惰性求值的链，最后用一个及早求值的操作返回想要的结果，这正是

它的合理之处。

3.3 常用的流操作

3.3.1　collect(toList())

collect(toList())方法由Stream里的值生成一个列表，是一个及早求值操作。

3.3.2 map

如果有一个函数可以将一种类型的值转换成另外一种类型，map 操作就可以

使用该函数，将一个流中的值转换成一个新的流。

List<String> collected = Stream.of("a", "b", "hello")

.map(string -> string.toUpperCase())

.collect(toList());

assertEquals(asList("A", "B", "HELLO"), collected);

参数和返回值不必属于同一种类型，但是Lambda 表达式必须是Function 接口的一个实例，Function 接口是只包含一个参数的普通函数接口。

3.3.3　filter

遍历数据并检查其中的元素时，可尝试使用Stream 中提供的新方法filter。

List<String> beginningWithNumbers= Stream.of("a", "1abc", "abc1")

.filter(value -> isDigit(value.charAt(0)))

.collect(toList());

assertEquals(asList("1abc"), beginningWithNumbers);

经过过滤，Stream 中符合条件的，即Lambda 表达式值为true 的元素被保留下来。该Lambda 表达式的函数接口正是前面章节中介绍过的Predicate。

3.3.4　flatMap

flatMap 方法可用Stream 替换值，然后将多个Stream 连接成一个Stream。

List<Integer> together = Stream.of(asList(1, 2), asList(3, 4))

.flatMap(numbers -> numbers.stream())

.collect(toList());

assertEquals(asList(1, 2, 3, 4), together);

调用stream 方法，将每个列表转换成Stream 对象，其余部分由flatMap 方法处理。

flatMap 方法的相关函数接口和map 方法的一样，都是Function 接口，只是方法的返回值

限定为Stream 类型罢了。

3.3.5 max和min

List<Track> tracks = asList(new Track("Bakai", 524),

new Track("Violets for Your Furs", 378),

new Track("Time Was", 451));

Track shortestTrack = tracks.stream()

.min(Comparator.comparing(track -> track.getLength()))

.get();

assertEquals(tracks.get(1), shortestTrack);

为了让Stream 对象按照曲目长度进行排序，需要传给它一个Comparator 对象。Java 8 提

供了一个新的静态方法comparing，使用它可以方便地实现一个比较器。放在以前，我们

需要比较两个对象的某项属性的值，现在只需要提供一个存取方法就够了。本例中使用

getLength方法。

花点时间研究一下comparing 方法是值得的。实际上这个方法接受一个函数并返回另一个函数。

还可以调用空Stream的max方法，返回Optional对象。Optional对象有点陌生，

它代表一个可能存在也可能不存在的值。如果Stream 为空，那么该值不存在，如果不为

空，则该值存在。通过调用get 方法可以取出Optional 对象中的值。

3.3.7 reduce

int count = Stream.of(1, 2, 3).reduce(0, (acc, element) -> acc + element);

assertEquals(6, count);

Lambda 表达式的返回值是最新的acc，是上一轮acc 的值和当前元素相加的结果。reducer

的类型是第2 章已介绍过的BinaryOperator。

3.3.8　整合操作

第一个要解决的问题是，找出某张专辑上所有乐队的国籍。艺术家列表里既有个人，也有

乐队。利用一点领域知识，假定一般乐队名以定冠词The 开头。当然这不是绝对的，但也

差不多。

可将这个问题分解为如下几个步骤。

1. 找出专辑上的所有表演者。

2. 分辨出哪些表演者是乐队。

3. 找出每个乐队的国籍。

4. 将找出的国籍放入一个集合。

1.Album 类有个getMusicians 方法，该方法返回一个Stream 对象，包含整张专辑中所有的

表演者；

2. 使用filter 方法对表演者进行过滤，只保留乐队；

3. 使用map 方法将乐队映射为其所属国家；

4. 使用collect(Collectors.toList())方法将国籍放入一个列表。

最后，整合所有的操作，就得到如下代码：

Set<String> origins = album.getMusicians()

.filter(artist -> artist.getName().startsWith("The"))

.map(artist -> artist.getNationality())

.collect(toSet());

3.4　重构遗留代码

public Set<String> findLongTracks(List<Album> albums) {

Set<String> trackNames = new HashSet<>();

for(Album album : albums) {

for (Track track : album.getTrackList()) {

if (track.getLength() > 60) {

String name = track.getName();

trackNames.add(name);

}

return trackNames;

}

第一步要修改的是for 循环。首先使用Stream 的forEach 方法替换掉for 循环，但还是暂

时保留原来循环体中的代码，这是在重构时非常方便的一个技巧。

public Set<String> findLongTracks(List<Album> albums) {

Set<String> trackNames = new HashSet<>();

albums.stream()

.forEach(album -> {

album.getTracks()

.forEach(track -> {

if (track.getLength() > 60) {

String name = track.getName();

trackNames.add(name);

}

});

return trackNames;

}

第二步，重构最内层的forEach方法

public Set<String> findLongTracks(List<Album> albums) {

Set<String> trackNames = new HashSet<>();

albums.stream()

.forEach(album -> {

album.getTracks()

.filter(track -> track.getLength() > 60)

.map(track -> track.getName())

.forEach(name -> trackNames.add(name));

});

return trackNames;

}

第三步，使用flatMap将多个流转换为一个流

public Set<String> findLongTracks(List<Album> albums) {

Set<String> trackNames = new HashSet<>();

albums.stream()

.flatMap(album -> album.getTracks())

.filter(track -> track.getLength() > 60)

.map(track -> track.getName())

.forEach(name -> trackNames.add(name));

return trackNames;

}

第四步，去掉手动创建一个Set 对象并将元素加入其中的操作。

public Set<String> findLongTracks(List<Album> albums) {

return albums.stream()

.flatMap(album -> album.getTracks())

.filter(track -> track.getLength() > 60)

.map(track -> track.getName())

.collect(toSet());

}

3.5　多次调用流操作

用户也可以选择每一步强制对函数求值，而不是将所有的方法调用链接在一起，但是，最好不要如此操作。

和流的链式调用相比有如下缺点：

代码可读性差，样板代码太多，隐藏了真正的业务逻辑；

效率差，每一步都要对流及早求值，生成新的集合；

代码充斥一堆垃圾变量，它们只用来保存中间结果，除此之外毫无用处；

难于自动并行化处理。

3.6　高阶函数

高阶函数是指接受另外一个函数作为参数，或返回一个函数的函数。高阶函数不难辨认：看函数签名就够了。如果函数的参数列表里包含函数接口，或该函数返回一个函数接口，那么该函数就是高阶函数。

Comparator 实际上应该是个函数，但是那时的Java 只有对象，因此才造出了一个类，一个匿名类。成为对象实属巧合，函数接口向正确的方向迈出了一步。

3.7　正确使用Lambda表达式

本章介绍的概念能够帮助用户写出更简单的代码，因为这些概念描述了数据上的操作，明

确了要达成什么转化，而不是说明如何转化。这种方式写出的代码，潜在的缺陷更少，更

直接地表达了程序员的意图。

明确要达成什么转化，而不是说明如何转化的另外一层含义在于写出的函数没有副作用。

这一点非常重要，这样只通过函数的返回值就能充分理解函数的全部作用。

3.8　要点回顾

内部迭代将更多控制权交给了集合类。

和Iterator 类似，Stream 是一种内部迭代方式。

将 Lambda表达式和Stream 上的方法结合起来，可以完成很多常见的集合操作。