10.5　下游收集器：filtering与flatMapping

问题

用户希望将元素作为下游收集器（downstream collector）的一部分进行筛选，或将集合的集合展平。

方案

使用 Java 9 为 Collectors 类新增的 filtering 和 flatMapping 方法。

讨论

Java 8 为 Collectors 类引入了 groupingBy 操作，用于根据特定的属性将对象分组。分组操作将产生一个“键 - 值列表”映射（Map>）。Java 8 还支持使用下游收集器，可以不必生成列表，而是对列表进行后期处理以获取其大小，或将列表映射为其他内容。

Java 9 新增了两种下游收集器，它们是 filtering 和 flatMapping。

  • filtering方法

假设存在两个类，一个类是 Task，该类包括描述预算的属性以及承担任务的开发人员列表；另一个类是 Developer，它的实例用于描述开发人员。两个类如例 10-21 所示。

例 10-21　Task 和 Developer 类

  1. public class Task {
  2.     private String name;
  3.     private long budget;
  4.     private List<Developer> developers = new ArrayList<>();
  5. 　
  6.     // 构造函数、getter、setter等
  7. }
  8. 　
  9. public class Developer {
  10.     private String name;
  11. 　
  12.     // 构造函数、getter、setter等
  13. }

首先，我们根据预算对任务进行分组。例 10-22 显示了一个简单的 groupingBy 操作。

例 10-22　根据预算对任务分组

  1. Developer venkat = new Developer("Venkat");
  2. Developer daniel = new Developer("Daniel");
  3. Developer brian = new Developer("Brian");
  4. Developer matt = new Developer("Matt");
  5. Developer nate = new Developer("Nate");
  6. Developer craig = new Developer("Craig");
  7. Developer ken = new Developer("Ken");
  8. 　
  9. Task java = new Task("Java stuff", 100);
  10. Task altJvm = new Task("Groovy/Kotlin/Scala/Clojure", 50);
  11. Task javaScript = new Task("JavaScript (sorry)", 100);
  12. Task spring = new Task("Spring", 50);
  13. Task jpa = new Task("JPA/Hibernate", 20);
  14. 　
  15. java.addDevelopers(venkat, daniel, brian, ken);
  16. javaScript.addDevelopers(venkat, nate);
  17. spring.addDevelopers(craig, matt, nate, ken);
  18. altJvm.addDevelopers(venkat, daniel, ken);
  19. 　
  20. List<Task> tasks = Arrays.asList(java, altJvm, javaScript, spring, jpa);
  21. 　
  22. Map<Long, List<Task>> taskMap = tasks.stream()
  23.         .collect(groupingBy(Task::getBudget));

由此建立了预算金额与分配该预算的任务列表之间的映射：

  1.  50: [Groovy/Kotlin/Scala/Clojure, Spring]
  2.  20: [JPA/Hibernate]
  3. 100: [Java stuff, JavaScript (sorry)]

如果只希望获取预算超过某个阈值的任务，可以添加一个 filter 操作，如例 10-23 所示。

例 10-23　利用 filter 操作进行分组

  1. taskMap = tasks.stream()
  2.         .filter(task -> task.getBudget() >= THRESHOLD)
  3.         .collect(groupingBy(Task::getBudget));

如果阈值为 50，程序的输出如下：

  1.  50: [Groovy/Kotlin/Scala/Clojure, Spring]
  2. 100: [Java stuff, JavaScript (sorry)]

可以看到，预算低于阈值的任务不会出现在输出映射中，不过仍然有办法显示这些任务：在 Java 9 中，Collectors 类新增了一个名为 filtering 的静态方法，它与 filter 类似，只不过用于下游任务列表的筛选。filtering 方法的用法如例 10-24 所示。

例 10-24　利用下游筛选器进行分组

  1. taskMap = tasks.stream()
  2.     .collect(groupingBy(Task::getBudget,
  3.           filtering(task -> task.getBudget() >= 50, toList())));

此时，所有预算金额都会以键的形式显示出来，但预算低于阈值的任务不会出现在列表值中：

  1.  50: [Groovy/Kotlin/Scala/Clojure, Spring]
  2.  20: []
  3. 100: [Java stuff, JavaScript (sorry)]

因此，filtering 操作是一种下游收集器，可以对分组操作产生的列表操作。

  • flatMapping方法

那么，如何获取承担每项任务的开发人员列表呢？如例 10-25 所示，借由基本的分组操作，可以根据任务名对任务分组。

例 10-25　根据任务名分组

  1. Map<String, List<Task>> tasksByName = tasks.stream()
  2.         .collect(groupingBy(Task::getName));

（格式化后的）输出如下：

  1.                  Java stuff: [Java stuff]
  2. Groovy/Kotlin/Scala/Clojure: [Groovy/Kotlin/Scala/Clojure]
  3.          JavaScript (sorry): [JavaScript (sorry)]
  4.                      Spring: [Spring]
  5.               JPA/Hibernate: [JPA/Hibernate]

为获取与任务关联的开发人员列表，我们使用下游收集器 mapping，如例 10-26 所示。

例 10-26　承担每项任务的开发人员列表

  1. Map<String, Set<List<Developer>>> map = tasks.stream()
  2.         .collect(groupingBy(Task::getName,
  3.               Collectors.mapping(Task::getDevelopers, toSet())));

不过，返回类型是 Set>，而我们需要的是一个下游 flatMap 操作来展平集合的集合。为此，可以使用 Collectors 类新增的 flatMapping 方法，如例 10-27 所示。

例 10-27　利用 flatMapping 方法获取一组开发人员

  1. Map<String, Set<Developer>> task2setdevs = tasks.stream()
  2.         .collect(groupingBy(Task::getName,
  3.                 Collectors.flatMapping(task -> task.getDevelopers().stream(),
  4.                 toSet())));

（格式化后的）输出如下：

  1.                  Java stuff: [Daniel, Brian, Ken, Venkat]
  2. Groovy/Kotlin/Scala/Clojure: [Daniel, Ken, Venkat]
  3.          JavaScript (sorry): [Nate, Venkat]
  4.                      Spring: [Craig, Ken, Matt, Nate]
  5.               JPA/Hibernate: []

Collectors.flatMapping 方法类似于 Stream.flatMap 方法。需要注意的是，flatMapping 方法的第一个参数应是一个流，它可以为空，或不依赖于数据源。

另见

有关下游收集器的讨论请参见范例 4.6，有关 flatMap 操作的讨论请参见范例 3.11。