5.3　映射

一个非常常见的数据处理套路就是从某些对象中选择信息。比如在SQL里，你可以从表中选择一列。Stream API也通过map和flatMap方法提供了类似的工具。

5.3.1　对流中每一个元素应用函数

流支持map方法，它会接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素（使用映射一词，是因为它和转换类似，但其中的细微差别在于它是“创建一个新版本”而不是去“修改”）。例如，下面的代码把方法引用Dish::getName传给了map方法，来提取流中菜肴的名称：

List<String> dishNames = menu.stream()
                             .map(Dish::getName)
                             .collect(toList());

因为getName方法返回一个String，所以map方法输出的流的类型就是Stream 。

让我们看一个稍微不同的例子，来巩固一下对map的理解。给定一个单词列表，你想要返回另一个列表，显示每个单词中有几个字母。怎么做呢？你需要对列表中的每个元素应用一个函数。这听起来正好该用map方法去做！应用的函数应该接受一个单词，并返回其长度。你可以像下面这样，给map传递一个方法引用String::length来解决这个问题：

List<String> words = Arrays.asList("Modern", "Java", "In", "Action");
List<Integer> wordLengths = words.stream()
                                 .map(String::length)
                                 .collect(toList());

现在回到提取菜名的例子。如果你要找出每道菜的名称有多长，该怎么做？可以像下面这样，再链接上一个map：

List<Integer> dishNameLengths = menu.stream()
                                    .map(Dish::getName)
                                    .map(String::length)
                                    .collect(toList());

5.3.2　流的扁平化

你已经看到如何使用map方法返回列表中每个单词的长度了。让我们拓展一下：对于一张单词表，如何返回一张列表，列出里面各不相同的字符呢？例如，给定单词列表["Hello","World"]，你想要返回列表["H","e","l", "o","W","r","d"]。

你可能会认为这很容易，你可以把每个单词映射成一张字符表，然后调用distinct来过滤重复的字符。第一个版本可能是这样的：

words.stream()
     .map(word -> word.split(""))
     .distinct()
     .collect(toList());

这个方法的问题在于，传递给map方法的Lambda为每个单词返回了一个String[]（String列表）。因此，map返回的流实际上是Stream类型的。你真正想要的是用Stream来表示一个字符流。图5-5说明了这个问题。

图 5-5　不正确地使用map找出单词列表中各不相同的字符

幸好可以用flatMap来解决这个问题！下面一步步来看怎么解决它。

• 尝试使用map和Arrays.stream()

首先，你需要一个字符流，而不是数组流。有一个叫作Arrays.stream()的方法可以接受一个数组并产生一个流，例如：

String[] arrayOfWords = {"Goodbye", "World"};
Stream<String> streamOfwords = Arrays.stream(arrayOfWords);

把它用在前面的那个流水线里，看看会发生什么：

words.stream()
     .map(word -> word.split(""))       ←---- 将每个单词转换为由其字母构成的数组
     .map(Arrays::stream)       ←---- 让每个数组变成一个单独的流
     .distinct()
     .collect(toList());

当前的解决方案仍然搞不定！这是因为，你现在得到的是一个流的列表（更准确地说是List>）！的确，你先是把每个单词转换成一个字母数组，然后把每个数组变成了一个独立的流。

• 使用flatMap

你可以像下面这样使用flatMap来解决这个问题：

List<String> uniqueCharacters =
  words.stream()
       .map(word -> word.split(""))       ←---- 将每个单词转换为由其字母构成的数组
       .flatMap(Arrays::stream)       ←---- 将各个生成流扁平化为单个流
       .distinct()
       .collect(toList());

使用flatMap方法的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所有使用flatMap(Arrays::stream)时生成的单个流都被合并起来，即扁平化为一个流。图5-6说明了使用flatMap方法的效果。把它和图5-5中map的效果比较一下。

图 5-6　使用flatMap找出单词列表中各不相同的字符

一言以蔽之，flatMap方法让你把一个流中的每个值都换成另一个流，然后把所有的流连接起来成为一个流。

第11章会讨论更高级的Java 8模式，比如使用新的Optional类进行null检查时会再来看看flatMap。为巩固你对于map和flatMap的理解，试试测验5.2吧。

测验5.2：映射

(1) 给定一个数字列表，如何返回一个由每个数的平方构成的列表呢？例如，给定[1, 2, 3, 4, 5]，应该返回[1, 4, 9, 16, 25]。

答案：你可以利用map方法的Lambda，接受一个数字，并返回该数字平方的Lambda来解决这个问题。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squares =
    numbers.stream()
           .map(n -> n * n)
           .collect(toList());

(2) 给定两个数字列表，如何返回所有的数对呢？例如，给定列表[1, 2, 3]和列表[3, 4]，应该返回[(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)]。为简单起见，你可以用有两个元素的数组来代表数对。

答案：你可以使用两个map来迭代这两个列表，并生成数对。但这样会返回一个Stream >。你需要让生成的流扁平化，以得到一个Stream。这正是flatMap所做的：

List<Integer> numbers1 = Arrays.asList(1, 2, 3);
List<Integer> numbers2 = Arrays.asList(3, 4);
List<int[]> pairs =
    numbers1.stream()
            .flatMap(i -> numbers2.stream()
                                  .map(j -> new int[]{i, j})
                    )
            .collect(toList());

(3) 如何扩展前一个例子，只返回总和能被3整除的数对呢？

答案：你在前面看到了，filter可以配合谓词使用来筛选流中的元素。因为在flatMap操作后，你有了一个代表数对的int[]流，所以只需要一个谓词来检查总和是否能被3整除就可以了：

List<Integer> numbers1 = Arrays.asList(1, 2, 3);
List<Integer> numbers2 = Arrays.asList(3, 4);
List<int[]> pairs =
    numbers1.stream()
            .flatMap(i ->
                       numbers2.stream()
                               .filter(j -> (i + j) % 3 == 0)
                               .map(j -> new int[]{i, j})
                    )
            .collect(toList());

结果是[(2, 4), (3, 3)]。