flatMap() Method in Java 8

2025 年 5 月 7 日 | 阅读 10 分钟

在Java 8 Streams中，flatMap()方法将操作应用于映射函数，并提供元素值的流。这意味着在每个元素的每次迭代中，map()方法都会创建一个单独的新流。通过使用扁平化机制，它将所有流合并成一个单一的结果流。简而言之，它用于将“流的流”转换为“值的列表”。

flatMap()方法的工作方式如下：

扁平化（Flattening）：它将多个集合或数组合并成一个单一的流。
中间操作（Intermediate Operation）：它返回一个新的流，并且可以与其他流操作链接。
无状态函数（Stateless Function）：flatMap()中使用的映射函数是无状态且非干涉的。

语法

该方法接受一个函数作为参数。它接受T作为参数，并返回R的流。

R: 这是一个类型参数，表示新流的元素类型。

mapper: 这是一个参数，是一个非干涉、无状态的函数，应用于每个元素。它产生一个新值流。

mapper具有以下属性：

非干涉（Non-Interfering）：该属性表示mapper不会更改输入流中的元素。相反，它为输入流中的每个元素生成一个不同的结果。

无状态（Stateless）：与依赖于先前处理过的项的状态化行为相反，无状态行为独立处理每个元素。因此，对于给定的输入，mapper在不考虑先前元素的情况下始终产生相同的输出。

总之，我们可以说flatMap()方法有助于将**Stream<Stream<T>>**转换为**Stream<T>**。它同时执行**扁平化（flat或flatten）**和**映射（map）**。Stream.flatMap()方法结合了这两种操作，即flat和map。

Java Stream.flatMap()方法的返回值

Java的**flatMap()**方法返回一个类型为**R**的新流。从语法中讨论的方法签名可以看出这一点。

该方法，**flatMap()**，暗示了两个不同的操作：

映射（Mapping）：原始流的每个元素都映射到一个类型为**R**的元素流。
扁平化（Flattening）：这些元素流然后被扁平化成一个单一的流。

让我们理解扁平化的含义。

什么是扁平化？

扁平化是指将嵌套的数据结构（例如集合的集合）转换为单一的、扁平的结构的过程。当我们在编程中想要简化嵌套数据（如列表或数组）到单一列表或数组时，通常会使用它。

在Java中，可以使用流来实现这一点，我们可以将列表的列表转换为单个列表。flatMap()方法通常在Java中用于执行扁平化。

例如，将整数列表的列表转换为单个整数列表，消除任何嵌套结构，从而得到一个一维集合。

扁平化示例

考虑以下列表的列表：

扁平化之前 [[1, 2, 3, 4], [7, 8, 9, 0], [5, 6], [12, 18, 19, 20, 17], [22]]

扁平化之后 [1, 2, 3, 4, 7, 8, 9, 0, 5, 6, 12, 18, 19, 20, 17, 22]

flatMap()方法示例

List country = Stream.of(Arrays.asList("Colombia", "Finland", "Greece", "Iceland", "Liberia", "Mali", "Mauritius"), Arrays.asList("Peru", "Serbia", "Singapore", "Turkey", "Uzbekistan", "Yemen", "Zimbabwe", "Greece", "Iceland")).flatMap(List::stream) .collect(Collectors.toList());  

我们可以使用List::stream作为映射函数在流上调用flatMap()方法。执行流的终止操作时，flatMap()的每个元素都会提供一个单独的流。在最后阶段，flatMap()方法将所有流转换为一个新的流。在上面的流中，我们观察到它不包含重复值。

让我们创建一个Java程序并使用flatMap()方法。

示例

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
    public static void main(String[] args) {
        // Creating individual product lists
        List<String> productList1 = Arrays.asList("Printer", "Mouse", "Keyboard", "Motherboard");
        List<String> productList2 = Arrays.asList("Scanner", "Projector", "Light Pen");
        List<String> productList3 = Arrays.asList("Pen Drive", "Charger", "WIFI Adapter", "Cooling Fan");
        List<String> productList4 = Arrays.asList("CPU Cabinet", "WebCam", "USB Light", "Microphone", "Power Cable");
        // Creating a list of lists to hold all the product lists
        List<List<String>> allProducts = new ArrayList<>();       
        // Adding product lists to the main list
        allProducts.add(productList1);
        allProducts.add(productList2);
        allProducts.add(productList3);
        allProducts.add(productList4);
        // Output the original nested structure (before flattening)
        System.out.println("List Before Applying Mapping and Flattening: ");
        System.out.println(allProducts);
        System.out.println();
        // Flattening the list using the flatMap() function
        List<String> flatMapList = allProducts.stream()
                                              .flatMap(productList -> productList.stream()) // Flatten the list of lists
                                              .collect(Collectors.toList()); // Collect the result into a single list
      // Output the flattened list (after applying flatMap)
        System.out.println("List After Applying Mapping and Flattening Operation: ");
        System.out.println(flatMapList);
    }
}

编译并运行

输出

List Before Applying mapping and Flattening:
[Printer, Mouse, Keyboard, Motherboard, Scanner, Projector, Lighten, Pen Drive, Charger, WIFI Adapter, Cooling Fan, CPU Cabinet, WebCam, USB Light, Microphone]
List After Applying Mapping and Flattening Operation:
[Printer, Mouse, Keyboard, Motherboard, Scanner, Projector, Light Pen, Pen Drive, Charger, WIFI Adapter, Cooling Fan, CPU Cabinet, WebCam, USB Light, Microphone]

Stream.flatMap()方法的使用场景

将嵌套列表扁平化为列表

将嵌套列表扁平化为单个列表是处理复杂数据结构时的常见操作。在Java 8中，可以使用flatMap()方法高效地实现这一点。

示例

import java.util.Arrays; // Importing Arrays utility class  
import java.util.List; // Importing List interface  
import java.util.stream.Collectors; // Importing Collectors utility class for stream collection  
public class Main { // Declaring the Main class  
    public static void main(String[] args) { // Main method where the program execution begins  
        // Creating a nested list (a list of lists) with integers  
        List<List<Integer>> nestedList = Arrays.asList(  
            Arrays.asList(1, 2, 3), // First inner list  
            Arrays.asList(4, 5, 6), // Second inner list  
            Arrays.asList(7, 8, 9)  // Third inner list  
        );  
        // Flattening the nested list into a single list of integers  
        List<Integer> flattenedList = nestedList.stream() // Creating a stream from the nested list  
            .flatMap(List::stream) // Flattening each inner list into a single stream of integers  
            .collect(Collectors.toList()); // Collecting the flattened stream into a new list  
        // Printing the flattened list to the console  
        System.out.println(flattenedList); // Expected output: [1, 2, 3, 4, 5, 6, 7, 8, 9]  
    }  
}  

编译并运行

输出

[1, 2, 3, 4, 5, 6, 7, 8, 9]

将嵌套数组扁平化为列表

将嵌套数组扁平化为单个列表是与扁平化嵌套列表类似的另一个常见操作。在Java 8中，也可以使用**flatMap()**方法高效地实现这一点，但处理数组的方式略有不同。

示例

import java.util.Arrays; // Importing Arrays utility class  
import java.util.List; // Importing List interface  
import java.util.stream.Collectors; // Importing Collectors utility class for stream collection  
import java.util.stream.Stream; // Importing Stream interface  
public class Main{ // Declaring the Main class  
    public static void main(String[] args) { // Main method where the program execution begins  
        // Creating a nested array (an array of arrays) with integers  
        Integer[][] nestedArray = {  
            {1, 2, 3}, // First inner array  
            {4, 5, 6}, // Second inner array  
            {7, 8, 9}  // Third inner array  
        };  
        // Flattening the nested array into a single list of integers  
        List<Integer> flattenedList = Arrays.stream(nestedArray) // Creating a stream from the nested array  
            .flatMap(Arrays::stream) // Flattening each inner array into a single stream of integers  
            .collect(Collectors.toList()); // Collecting the flattened stream into a new list  
        // Printing the flattened list to the console  
        System.out.println(flattenedList); // Expected output: [1, 2, 3, 4, 5, 6, 7, 8, 9]  
    }  
}  

编译并运行

输出

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Java Stream.flatMap()与原始类型

在Java 8中，Stream API为原始类型提供了专门的流，例如**IntStream、LongStream**和**DoubleStream**。当使用这些原始流时，您可能需要使用**flatMap()**方法来扁平化原始类型的嵌套结构。

示例

import java.util.Arrays;  // Importing Arrays utility class
import java.util.List;    // Importing List interface
import java.util.stream.Collectors; // Importing Collectors utility class for stream collection
import java.util.stream.IntStream; // Importing IntStream for handling primitive int streams
public class Main{ // Declaring the Main class
    public static void main(String[] args) { // Main method where the program execution begins
        // Creating a nested array (an array of arrays) with primitive int values
        int[][] nestedIntArray = {
            {1, 2, 3}, // First inner array
            {4, 5, 6}, // Second inner array
            {7, 8, 9}  // Third inner array
        };
        // Flattening the nested array into a single list of Integers using flatMap
        List<Integer> flattenedList = Arrays.stream(nestedIntArray) // Creating a stream from the nested array
            .flatMapToInt(IntStream::of) // Flattening each inner array into a single IntStream.boxed() // Boxing the primitive int values into Integer objects
            .collect(Collectors.toList()); // Collecting the boxed integers into a new list
        // Printing the flattened list to the console
        System.out.println(flattenedList); // Expected output: [1, 2, 3, 4, 5, 6, 7, 8, 9]
    }
}

编译并运行

输出

[1, 2, 3, 4, 5, 6, 7, 8, 9]

文本文件的单词计数

在文本处理和分析中，计算文本文件中的单词数量是一项基本任务。此操作在各种应用中非常有用，例如文本分析、内容管理和数据预处理。在Java中，我们可以使用Stream API高效地执行单词计数。Stream API提供了一种现代的、函数式的方法来处理元素序列，使其非常适合读取和操作文本文件等任务。

示例

import java.io.IOException; // Importing the IOException class for handling IO exceptions  
import java.nio.file.Files; // Importing the Files class for file operations  
import java.nio.file.Paths; // Importing the Paths class for dealing with file paths  
import java.util.Arrays; // Importing the Arrays class for working with arrays  
public class Main {  
    public static void main(String[] args) {  
        // Define the path to the text file  
        String filePath = "D://tpointtech//Demo.txt/";  
        try {  
            // Read all lines from the file and create a stream of lines  
            long wordCount = Files.lines(Paths.get(filePath))  
                // Split each line into words based on whitespace and create a stream of words  
                .flatMap(line -> Arrays.stream(line.trim().split("\\s+")))  
                // Filter out any empty words that may result from splitting  
                .filter(word -> !word.isEmpty())  
                // Count the number of words in the stream  
                .count();  
            // Print the word count to the console  
            System.out.println("Word count: " + wordCount);  
        } catch (IOException e) {  
            // Print the stack trace if an IOException occurs  
            e.printStackTrace();  
        }  
    }  
}  

编译并运行

输出

Word count: 37

Demo.txt

你好，**这是**一个示例文本文件。
它包含几个单词，分布在多行中。
我们正在使用**此**文件来测试单词计数程序。
每一行都将被读取和处理以计算单词数。

现在，我们已经理解了Stream类的两种方法，因为我们可以轻松地指出它们之间的关键区别。

Stream.flatMap()和Stream.map()方法之间的区别

下表描述了Stream.flatMap()和Stream.map()之间的关键区别。

方面	Stream.flatMap()	Stream.map()
处理	它处理流的流对象。	它处理对象的流。
映射和扁平化	它执行映射和扁平化。	它仅执行映射。
转换	它将数据从Stream<Stream<T>>转换为Stream<R>。	它将数据从Stream<T>转换为Stream<R>。
映射	它使用一对多映射。	它使用一对一映射。
产出	对于每个输入值，其mapper函数会产生多个值（值的流）。	对于每个输入值，其mapper函数会产生单个值。
用法	当mapper函数为每个输入值产生多个值时，使用flatMap()方法。	当mapper函数为每个输入值产生单个值时，使用map()方法。
示例	List<Integer> allDistinctNums = Stream.of(evens, odds, primes).flatMap(numList -> numList.stream()).distinct().collect(Collectors.toList());	List<Integer> stringLengths = Stream.of("ab", "abcd", "abc").map(String::length).collect(Collectors.toList());

要记住的重要事项

flatMap操作可以描述为带有扁平化的map。
它是一种惰性中间操作。
它将嵌套结构转换为扁平化的结构。
它克服了map()方法的一些限制。
它执行一对多映射。
它只需要一个称为mapper的参数，该参数本质上是非干涉和无状态的。

Java Stream.flatMap()方法MCQ

1. flatMap()方法执行以下哪种映射？

一对一
一对多
多对多
多对一

答案：2)

解释: 它执行一对多映射，涉及将一个值映射为零个或多个值。例如，当您将单个字符串流扁平化为零个或多个字符串值时，就会发生一对多映射。

2. flatMap()方法执行哪些操作？

映射
扁平化
映射和扁平化
以上都不是

答案：3)

解释: 它同时执行扁平化（flat或flatten）和映射（map）。Stream.flatMap()方法结合了这两种操作，即flat和map。

3. flatMap()方法中的mapper是什么？

数据类型
值
方法参数
以上全部

答案：3)

解释: 这是一个参数，是一个非干涉、无状态的函数，应用于每个元素。它产生一个新值流。

4. 关于flatMap()方法，以下哪项是正确的？

它是一种终止操作。
它用于将多个流合并为一个。
它将每个元素转换为一个流，并将它们合并成一个单一的流。
它用于并行处理。

答案：3)

解释: flatMap()方法将操作应用于映射函数，并提供元素值的流。这意味着在每个元素的每次迭代中，map()方法都会创建一个单独的新流。通过使用扁平化机制，它将所有流合并成一个单一的结果流。

5. 以下哪项是flatMap()方法的有效用例？

将列表的列表转换为单个列表。
根据谓词过滤元素。
对流中的元素进行排序。
将元素收集到映射中。

答案：1)

解释: flatMap()方法的使用场景包括：

文本文件的单词计数。
将嵌套列表转换为单个列表。
将嵌套数组转换为单个列表

下一主题Moser-de-bruijn-sequence-in-java

flatMap() Method in Java 8

Java Stream.flatMap()方法的返回值

什么是扁平化？

扁平化示例

flatMap()方法示例

示例

Stream.flatMap()方法的使用场景

将嵌套列表扁平化为列表

示例

将嵌套数组扁平化为列表

示例

Java Stream.flatMap()与原始类型

示例

文本文件的单词计数

示例

Demo.txt

Stream.flatMap()和Stream.map()方法之间的区别

Java Stream.flatMap()方法MCQ

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

flatMap() Method in Java 8

Java Stream.flatMap()方法的返回值

什么是扁平化？

扁平化示例

flatMap()方法示例

示例

Stream.flatMap()方法的使用场景

将嵌套列表扁平化为列表

示例

将嵌套数组扁平化为列表

示例

Java Stream.flatMap()与原始类型

示例

文本文件的单词计数

示例

Demo.txt

Stream.flatMap()和Stream.map()方法之间的区别

Java Stream.flatMap()方法MCQ

相关帖子

SOLID Principles in Java

Java 中的选择语句

Java 十六进制到二进制转换

Java 中的克隆类型

Java API

Java 中的计数器如何与日期配合使用

Java 中的 DoubleBuffer compact() 方法及示例

Java SonarQube

How to Set CLASSPATH in Java

Java 中二叉树的层序遍历

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器