flatMap() Method in Java 8

In Java 8 Streams, the flatMap() method applies an operation as a mapper function and provides a stream of element values. It means that in each iteration of each element, the map() method creates a separate new stream. By using the flattening mechanism, it merges all streams into a single resultant stream. In short, it is used to convert a Stream of streams into a list of values.

The flatMap() method works in the following way:

• Flattening: It combines multiple collections or arrays into a single stream.
• Intermediate Operation: It returns a new stream and can be chained with other stream operations.
• Stateless Function: The mapping function used in flatMap() is stateless and non-interfering.

Syntax:

The method takes a function as an argument. It accepts T as a parameter and returns a stream of R.

R: It is a type parameter that represents the element type of the new stream.

mapper: It is a parameter that is a non-interfering, stateless function to apply to each element. It produces a stream of new values.

The mapper has the following properties:

Non-Interfering: The property signifies that the mapper does not alter the elements within the input Stream. Instead, it generates a distinct result for each element in the input Stream.

Stateless: In contrast to stateful behavior, where actions rely on previously processed items, stateless behavior processes each element independently. Consequently, for a given input, the mapper consistently produces the same output without considering previous elements.

In short, we can say that the flatMap() method helps in converting Stream<Stream<T>> to Stream<T>. It performs flattening (flat or flatten) and mapping (map) simultaneously. The Stream.flatMap() method combines both the operations, i.e., flat and map.

Return Value of Java Stream.flatMap() Method

The Java flatMap() method returns a new Stream of type R. This is evident from the method signature discussed in the syntax.

The method, flatMap(), suggests two distinct operations:

1. Mapping: Each element of the original stream is mapped to a stream of elements of type R.
2. Flattening: These streams of elements are then flattened into a single stream.

Let's understand the meaning of flattening.

What is flattening?

Flattening refers to the process of converting a nested data structure (such as a collection of collections) into a single, flat structure. It is often used in programming when we want to simplify nested data like lists or arrays into a single list or array.

In Java, it can be achieved using streams, where we can convert a list of lists into a single list. The flatMap() method is commonly used in Java to perform flattening.

For example, converting a list of lists of integers into a single list of integers, eliminating any nested structure, results in a one-dimensional collection.

Flattening Example

Consider the following lists of lists:

Before Flattening: [[1, 2, 3, 4], [7, 8, 9, 0], [5, 6], [12, 18, 19, 20, 17], [22]]

After Flattening: [1, 2, 3, 4, 7, 8, 9, 0, 5, 6, 12, 18, 19, 20, 17, 22]

Example of the flatMap() Method

We can use a flatMap() method on a stream with the mapper function List::stream. On executing the stream terminal operation, each element of flatMap() provides a separate stream. In the final phase, the flatMap() method transforms all the streams into a new stream. In the above stream, we observe that it does not contain duplicate values.

Let's create a Java program and use the flatMap() method.

Output:

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] 

Use Cases of Stream.flatMap() Method

Flattening a Nested List to a List

Flattening a nested list into a single list is a common operation when dealing with complex data structures. In Java 8, it can be efficiently achieved by using the flatMap() method.

Output:

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

Flattening a Nested Array to a List

Flattening a nested array into a single list is another common operation similar to flattening a nested list. In Java 8, it can also be efficiently achieved by using the flatMap() method, but with a slight difference in handling arrays.

Output:

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

Java Stream.flatMap() with Primitive Types

In Java 8, the Stream API provides specialized streams for primitive types, such as IntStream, LongStream, and DoubleStream. When working with these primitive streams, you might need to use the flatMap() method to flatten nested structures of primitive types.

Output:

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

Word Count of a Text File

Counting the number of words in a text file is a fundamental task in text processing and analysis. This operation can be useful in various applications such as text analytics, content management, and data preprocessing. In Java, we can perform word count efficiently using the Stream API. The Stream API provides a modern, functional approach to processing sequences of elements, making it well-suited for tasks like reading and manipulating text files.

Output:

Word count: 37

Demo.txt

1. Hello, this is a sample text file.
2. It contains several words, spread across multiple lines.
3. We are using this file to test the word count program.
4. Each line will be read and processed to count the words.

Now, we have understood both the methods of the Stream class since we can easily point out the key differences between them.

Differences Between Stream.flatMap() and Stream.map() Method

The following table describes the key differences between Stream.flatMap() and Stream.map().

Important Points to Remember

1. The flatmap operation can be described as map with flattening.
2. It is a lazy and intermediate operation.
3. It transforms a nested structure into a flattened one.
4. It overcomes some of the limitations of the map() method.
5. It performs one-to-many mapping.
6. It only requires a parameter called mapper that is Non-Interfering and Stateless in nature.

Java Stream.flatMap() Method MCQs

1. Which of the following mappings is performed by the flatMap() method?

1. One-to-One
2. One-to-Many
3. Many-to-Many
4. Many-to-One

2. Which operations are performed by the flatMap() method?

1. Mapping
2. Flattening
3. Both Mapping and Flattening
4. None of the above

3. What is a mapper in the flatMap() method?

1. Data Type
2. Value
3. Method Parameter
4. All the above

4. Which of the following is true about flatMap() method?

1. It is a terminal operation.
2. It is used to merge multiple streams into one.
3. It transforms each element into a stream and combines them into a single stream.
4. It is used for parallel processing.

5. Which of the following is a valid use case for the flatMap() method?

1. Converting a list of lists into a single list.
2. Filtering elements based on a predicate.
3. Sorting elements in a stream.
4. Collecting elements into a map.