Java 下游收集器：filtering与flatMapping|极客教程

Java 下游收集器：filtering与flatMapping，用户希望将元素作为下游收集器（downstream collector）的一部分进行筛选，或将集合的集合展平。使用 Java 9 为 Collectors 类新增的 filtering 和 flatMapping 方法。Java 8 为 Collectors 类引入了 groupingBy 操作，用于根据特定的属性将对象分组。

Java 下游收集器：filtering与flatMapping 问题描述

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

Java 下游收集器：filtering与flatMapping 解决方案

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

Java 下游收集器：filtering与flatMapping 具体实例

Java 8 为 Collectors 类引入了 groupingBy 操作，用于根据特定的属性将对象分组。分组操作将产生一个“键 – 值列表”映射（Map<K, List<T>>）。Java 8 还支持使用下游收集器，可以不必生成列表，而是对列表进行后期处理以获取其大小，或将列表映射为其他内容。
Java 9 新增了两种下游收集器，它们是 filtering 和 flatMapping。
1.filtering方法
假设存在两个类，一个类是 Task，该类包括描述预算的属性以及承担任务的开发人员列表；另一个类是 Developer，它的实例用于描述开发人员。两个类如例 10-21 所示。

例 10-21　Task 和 Developer 类

public class Task {
    private String name;
    private long budget;
    private List<Developer> developers = new ArrayList<>();
　
    // 构造函数、getter、setter等
}
　
public class Developer {
    private String name;
　
    // 构造函数、getter、setter等
}

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

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

Developer venkat = new Developer("Venkat");
Developer daniel = new Developer("Daniel");
Developer brian = new Developer("Brian");
Developer matt = new Developer("Matt");
Developer nate = new Developer("Nate");
Developer craig = new Developer("Craig");
Developer ken = new Developer("Ken");
　
Task java = new Task("Java stuff", 100);
Task altJvm = new Task("Groovy/Kotlin/Scala/Clojure", 50);
Task javaScript = new Task("JavaScript (sorry)", 100);
Task spring = new Task("Spring", 50);
Task jpa = new Task("JPA/Hibernate", 20);
　
java.addDevelopers(venkat, daniel, brian, ken);
javaScript.addDevelopers(venkat, nate);
spring.addDevelopers(craig, matt, nate, ken);
altJvm.addDevelopers(venkat, daniel, ken);
　
List<Task> tasks = Arrays.asList(java, altJvm, javaScript, spring, jpa);
　
Map<Long, List<Task>> taskMap = tasks.stream()
        .collect(groupingBy(Task::getBudget));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

例 10-25　根据任务名分组

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

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

                 Java stuff: [Java stuff]
Groovy/Kotlin/Scala/Clojure: [Groovy/Kotlin/Scala/Clojure]
         JavaScript (sorry): [JavaScript (sorry)]
                     Spring: [Spring]
              JPA/Hibernate: [JPA/Hibernate]

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

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

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

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

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

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

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

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