深挖 Java8的Stream.flatMap：你不知道的流式操作技巧

flatMap() 是 Java8 Stream API 的核心方法之一，主要用于将嵌套结构展开并生成一个新的流。它的强大之处在于能够处理复杂数据结构并将其转换为简单的线性流。以下是 flatMap() 的常见用法和应用场景：

1. 将嵌套集合展开为单一流

用法

处理嵌套的 List 或 Set，将其扁平化为单一流。

示例代码

import java.util.*;
import java.util.stream.Collectors;

public class NestedListExample {
    public static void main(String[] args) {
        List<List<String>> nestedList = Arrays.asList(
            Arrays.asList("a", "b"),
            Arrays.asList("c", "d", "e"),
            Arrays.asList("f", "g")
        );

        // 使用 flatMap 将嵌套集合展开为单一流
        List<String> flatList = nestedList.stream()
                .flatMap(List::stream)
                .collect(Collectors.toList());

        System.out.println("Flattened List: " + flatList);
    }
}

输出

Flattened List: [a, b, c, d, e, f, g]

2. 字符串拆分为单词流

用法

将字符串列表中的每个字符串拆分为单词，然后合并为单一流。

示例代码

import java.util.*;
import java.util.stream.Collectors;

public class StringSplitExample {
    public static void main(String[] args) {
        List<String> sentences = Arrays.asList(
            "Java is powerful",
            "Stream API is useful",
            "flatMap is amazing"
        );

        // 使用 flatMap 拆分字符串为单词流
        List<String> words = sentences.stream()
                .flatMap(sentence -> Arrays.stream(sentence.split(" ")))
                .collect(Collectors.toList());

        System.out.println("Words: " + words);
    }
}

输出

Words: [Java, is, powerful, Stream, API, is, useful, flatMap, is, amazing]

3. 处理多对多关系 (One-to-Many)

用法

通过映射关系生成多个结果，并将其合并为单一流。

示例代码

import java.util.*;
import java.util.stream.Collectors;

public class OneToManyExample {
    public static void main(String[] args) {
        Map<String, List<String>> products = new HashMap<>();
        products.put("Fruits", Arrays.asList("Apple", "Banana"));
        products.put("Vegetables", Arrays.asList("Carrot", "Lettuce"));
        products.put("Dairy", Arrays.asList("Milk", "Cheese"));

        // 使用 flatMap 生成所有商品的流
        List<String> allProducts = products.values().stream()
                .flatMap(List::stream)
                .collect(Collectors.toList());

        System.out.println("All Products: " + allProducts);
    }
}

输出

All Products: [Apple, Banana, Carrot, Lettuce, Milk, Cheese]

4. 处理 Optional 流

用法

将包含 Optional 的流展开为非空值的单一流。

示例代码

import java.util.*;
import java.util.Optional;
import java.util.stream.Collectors;

public class OptionalExample {
    public static void main(String[] args) {
        List<Optional<String>> optionalList = Arrays.asList(
            Optional.of("A"),
            Optional.empty(),
            Optional.of("B"),
            Optional.of("C")
        );

        // 使用 flatMap 提取非空值
        List<String> nonEmptyValues = optionalList.stream()
                .flatMap(Optional::stream)
                .collect(Collectors.toList());

        System.out.println("Non-empty values: " + nonEmptyValues);
    }
}

输出

Non-empty values: [A, B, C]

5. 生成笛卡尔积

用法

两个集合之间生成所有可能的组合。

示例代码

import java.util.*;
import java.util.stream.Collectors;

public class CartesianProductExample {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("A", "B", "C");
        List<Integer> list2 = Arrays.asList(1, 2, 3);

        // 使用 flatMap 生成笛卡尔积
        List<String> cartesianProduct = list1.stream()
                .flatMap(str -> list2.stream()
                        .map(num -> str + num))
                .collect(Collectors.toList());

        System.out.println("Cartesian Product: " + cartesianProduct);
    }
}

输出

Cartesian Product: [A1, A2, A3, B1, B2, B3, C1, C2, C3]

6. 动态文件读取

用法

从多个文件读取所有行并合并为一个流。

示例代码

import java.io.IOException;
import java.nio.file.*;
import java.util.stream.Stream;

public class FileReadingExample {
    public static void main(String[] args) throws IOException {
        List<Path> files = Arrays.asList(
            Paths.get("file1.txt"),
            Paths.get("file2.txt")
        );

        // 使用 flatMap 合并多个文件的行
        try (Stream<String> lines = files.stream()
                .flatMap(path -> {
                    try {
                        return Files.lines(path);
                    } catch (IOException e) {
                        e.printStackTrace();
                        return Stream.empty();
                    }
                })) {
            lines.forEach(System.out::println);
        }
    }
}

小结

flatMap() 的核心功能是将多个流或嵌套结构展开为一个流，这使得它在处理复杂数据结构、多对多关系以及动态数据合并时非常有用。通过灵活应用 flatMap()，可以极大地简化代码逻辑，提高数据处理效率和代码可读性。

欢迎follow同名gzh: 加瓦点灯， 每天推送干货知识

本文由mdnice多平台发布