使用Java Stream高效提取嵌套集合中的唯一元素

在现代Java开发中，处理集合数据是日常任务之一。当数据结构涉及嵌套集合时，例如一个对象包含一个列表，而列表中的每个元素又包含另一个列表时，提取特定信息并确保其唯一性会变得复杂。本教程将以一个常见的场景为例：从List中获取所有员工居住过的唯一城市名称。

假设我们有以下两个Java类定义：

import java.util.List;
import java.util.Set;
import java.util.HashSet;
import java.util.stream.Collectors;
import java.util.ArrayList;
import java.util.Arrays;

public class EmployeeDataProcessor {

    public static class Employee {
        private String name;
        private List
 addresses; // 员工可以有多个地址

        public Employee(String name, List
 addresses) {
            this.name = name;
            this.addresses = addresses;
        }

        public List
 getAddresses() {
            return addresses;
        }

        public String getName() {
            return name;
        }
    }

    public static class Address {
        private String city;
        private String street;

        public Address(String city, String street) {
            this.city = city;
            this.street = street;
        }

        public String getCity() {
            return city;
        }

        public String getStreet() {
            return street;
        }
    }

    // ... 后续方法将在此处添加
}

我们的目标是从一个List中，提取所有员工的地址所对应的城市名称，并最终得到一个包含所有唯一城市名称的Set。

传统循环方式

在Java 8引入Stream API之前，我们通常会使用嵌套的for循环来解决这个问题：

立即学习“Java免费学习笔记（深入）”；

public static Set getCityUniqueNameTraditional(List employees){
    Set cityUniqueNames = new HashSet<>();
    for(Employee e : employees){
        List
 addressList = e.getAddresses();
        for(Address add : addressList){
            cityUniqueNames.add(add.getCity());
        }
    }
    return cityUniqueNames;
}

这种方式虽然有效，但代码相对冗长，可读性在处理更复杂的逻辑时会下降。接下来，我们将探讨如何使用Java Stream API来简化这一过程。

使用 Stream.flatMap() 扁平化集合

Stream.flatMap() 操作是处理嵌套集合的强大工具。它将流中的每个元素转换成一个零个、一个或多个元素的流，然后将这些新的流连接（扁平化）成一个单一的流。

知鹿匠

知鹿匠教师AI工具，新课标教案_AI课件PPT_作业批改

下载

对于我们的场景，flatMap() 可以将Stream中的每个Employee对象，转换为其内部List

以下是使用flatMap()实现的代码：

public static Set getCityUniqueNameWithFlatMap(List employees) {
    return employees.stream() // 1. 将List转换为Stream
        .flatMap(e -> e.getAddresses().stream()) // 2. 将每个Employee对象映射为其地址列表的Stream，并扁平化
        .map(Address::getCity) // 3. 将每个Address对象映射为其城市名称（String）
        .collect(Collectors.toSet()); // 4. 将所有城市名称收集到一个Set中，自动处理唯一性
}

代码解析：

1. employees.stream(): 创建一个Stream。
2. flatMap(e -> e.getAddresses().stream()): 这是核心步骤。对于流中的每个Employee对象e，我们调用e.getAddresses()获取其List
   ，然后通过.stream()将其转换为Stream

   。flatMap()负责将所有这些独立的Stream

   连接成一个统一的Stream

   。
3. map(Address::getCity): 现在我们有了一个Stream
   ，map()操作将每个Address对象转换为其city属性（一个String）。
4. collect(Collectors.toSet()): 最后，collect()操作将流中的所有String（城市名称）收集到一个Set中。Set的特性保证了最终结果中只包含唯一的城市名称。

使用 Stream.mapMulti() 扁平化集合

Stream.mapMulti() 是Java 16引入的一个新操作，它提供了比flatMap()更灵活且有时更高效的扁平化方式。mapMulti()接受一个BiConsumer，该BiConsumer的第一个参数是当前流的元素，第二个参数是一个Consumer，你可以通过调用这个Consumer来向结果流中“发出”零个、一个或多个元素。

以下是使用mapMulti()实现的代码：

public static Set getCityUniqueNameWithMapMulti(List employees) {
    return employees.stream() // 1. 将List转换为Stream
        .
mapMulti((employee, addressConsumer) -> // 2. 使用mapMulti处理每个Employee
            employee.getAddresses().forEach(addressConsumer)) // 3. 对于每个Employee的地址列表，将其每个地址“发出”到结果流
        .map(Address::getCity) // 4. 将每个Address对象映射为其城市名称（String）
        .collect(Collectors.toSet()); // 5. 将所有城市名称收集到一个Set中
}

代码解析：

1. employees.stream(): 创建一个Stream。
2. mapMulti(...): 这里我们显式指定了mapMulti将产生Address类型的元素，这有助于类型推断。
3. ((employee, addressConsumer) -> employee.getAddresses().forEach(addressConsumer)): 这是mapMulti的核心逻辑。
   • employee是当前流中的Employee对象。
   • addressConsumer是一个Consumer
     ，用于将Address对象“发出”到下游流。
   • employee.getAddresses().forEach(addressConsumer): 对于当前Employee的每个Address，我们都调用addressConsumer.accept(address)，从而将该Address添加到mapMulti生成的新流中。
4. map(Address::getCity): 同flatMap示例，将Address映射为String（城市名称）。
5. collect(Collectors.toSet()): 同flatMap示例，收集到Set中。

总结与注意事项