17370845950

本文深入探讨如何利用Java Stream API，从包含嵌套集合的对象列表中高效地提取唯一的字符串值。我们将重点介绍flatMap()和mapMulti()这两种强大的流操作，演示它们如何替代传统的嵌套循环，从而实现代码的简洁性、可读性以及潜在的性能优化。

在java应用开发中，我们经常会遇到处理复杂数据结构的需求，例如一个对象列表中包含另一个对象列表。当需要从这种嵌套结构中提取并聚合唯一的特定属性值时，传统的做法是使用嵌套的for循环。然而，java 8引入的stream api提供了一种更声明式、更简洁且通常更高效的解决方案。

考虑以下两个简单的Java类，它们代表了员工及其地址信息：

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

public class StreamUniqueValues {

    public static class Employee {
        private List addresses;

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

        public List getAddresses() {
            return addresses;
        }

        // 可以添加其他属性和方法
    }

    public static class Address {
        private String city;

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

        public String getCity() {
            return city;
        }

        // 可以添加其他属性和方法
    }

    // 传统方法获取唯一城市名
    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;
    }

    public static void main(String[] args) {
        // 示例数据
        List employees = new ArrayList<>();
        employees.add(new Employee(List.of(new Address("北京"), new Address("上海"))));
        employees.add(new Employee(List.of(new Address("上海"), new Address("广州"))));
        employees.add(new Employee(List.of(new Address("深圳"))));

        System.out.println("传统方法获取唯一城市名: " + getCityUniqueNameTraditional(employees));
        System.out.println("使用 flatMap 获取唯一城市名: " + getCityUniqueNameWithFlatMap(employees));
        System.out.println("使用 mapMulti 获取唯一城市名: " + getCityUniqueNameWithMapMulti(employees));
    }
}

我们的目标是从List中提取所有不重复的城市名称，并存储到一个Set中。上述getCityUniqueNameTraditional方法展示了使用嵌套for循环的传统实现方式。接下来，我们将探讨如何使用Stream API实现相同的目标。

1. 使用 Stream.flatMap() 扁平化流

Stream.flatMap()操作是处理嵌套集合的强大工具。它将流中的每个元素转换成一个流，然后将这些单独的流合并（扁平化）成一个单一的流。这对于将“流的流”转换为一个“流”非常有用。

工作原理

1. emp.stream(): 首先，我们将List转换为一个Stream。
2. .flatMap(e -> e.getAddresses().stream()): 这是核心步骤。对于流中的每个Employee对象e，我们调用e.getAddresses()获取其List，然后通过.stream()将其转换为一个Stream。flatMap()会将所有这些Stream合并成一个单一的Stream。
   • 注意事项: flatMap()期望一个函数返回一个Stream，而不是一个Collection。如果直接返回Collection，会导致编译错误或逻辑错误。
3. .map(Address::getCity): 现在我们有了一个包含所有Address对象的扁平化流。接下来，我们使用map()操作将每个Address对象转换为它的city字符串。
4. .collect(Collectors.toSet()): 最后，我们使用collect()操作将所有唯一的城市字符串收集到一个Set中。Collectors.toSet()会自动处理去重。

示例代码

public static Set getCityUniqueNameWithFlatMap(List employees) {
    return employees.stream()
        .flatMap(e -> e.getAddresses().stream()) // 将每个Employee的地址列表扁平化为Address流
        .map(Address::getCity)                  // 提取每个Address的城市名
        .collect(Collectors.toSet());           // 收集为Set以去重
}

2. 使用 Stream.mapMulti() 灵活转换（Java 16+）

Stream.mapMulti()是Java 16中引入的一个新操作，它提供了比flatMap()更灵活的转换方式。mapMulti()允许一个输入元素产生零个、一个或多个输出元素，并且可以通过一个BiConsumer回调函数来控制元素的发射。

工作原理

1. emp.stream(): 同样，我们从List开始创建一个Stream。
2. .mapMulti((e, consumer) -> e.getAddresses().forEach(consumer)): 这是mapMulti()的核心。
   • e：当前处理的Employee对象。
   • consumer：一个Consumer，用于接收我们希望添加到结果流中的元素。
   • e.getAddresses().forEach(consumer)：对于每个Employee，我们遍历其addresses列表，并将每个Address对象“提供”给consumer。这样，每个Address都会被添加到mapMulti的结果流中。
   • ：这是一个类型提示，告诉编译器我们期望mapMulti操作产生Address类型的元素。
3. .map(Address::getCity): 接下来，与flatMap示例相同，我们将Address流中的每个Address对象映射为其city字符串。
4. .collect(Collectors.toSet()): 最后，将所有唯一的城市字符串收集到一个Set中。

示例代码

public static Set getCityUniqueNameWithMapMulti(List employees) {
    return employees.stream()
        // 使用mapMulti将每个Employee的地址列表中的Address对象发射到流中
        .mapMulti((e, consumer) -> e.getAddresses().forEach(consumer))
        .map(Address::getCity)          // 提取城市名
        .collect(Collectors.toSet());   // 收集为Set以去重
}

3. flatMap() 与 mapMulti() 的选择与比较

• flatMap():

  • 优点: 语义清晰，当转换函数直接返回一个Stream时非常直观。
  • 适用场景: 最适合将“流的流”扁平化为单个流的场景。
  • 限制: 转换函数必须返回一个Stream。

• mapMulti():

  • 优点: 更加灵活。一个输入元素可以根据逻辑条件产生零个、一个或多个输出元素，而不需要显式创建中间流。这在某些复杂转换中可以避免不必要的流创建开销，可能带来轻微的性能优势。
  • 适用场景: 当转换逻辑比较复杂，或者一个输入元素可能不产生任何输出，或者产生多个不同类型的输出（尽管通常不推荐在同一个mapMulti中混合类型），或者需要更精细地控制元素发射时。
  • 限制: Java 16及更高版本才可用。回调函数BiConsumer的编写可能不如flatMap的Lambda表达式直观。

在上述“提取唯一城市名”的场景中，flatMap()和mapMulti()都能很好地完成任务，并且代码都比传统的嵌套循环更加简洁和易读。对于这种直接将集合转换为流并扁平化的场景，flatMap()通常是首选，因为它更直接地表达了“扁平化一个流的流”的意图。mapMulti()提供了更大的灵活性，可以在更复杂的转换逻辑中发挥作用。

总结

通过Stream.flatMap()或Stream.mapMulti()，我们可以优雅地处理嵌套集合，将复杂的数据结构扁平化，并在此基础上执行进一步的转换和聚合操作。这不仅使代码更加简洁、可读，而且充分利用了Java Stream API的并行处理潜力（如果适用），从而提升了开发效率和程序性能。在选择使用哪种方法时，可以根据Java版本、转换逻辑的复杂性以及个人偏好进行权衡。对于大多数将嵌套集合扁平化的场景，flatMap()是简洁而强大的选择。