Difference Between map() and flatmap() Method in Java 8

In the realm of functional programming in Java 8, the map() and flatMap() operations are fundamental components of the Stream API. These two methods, although seemingly similar in name, serve distinct purposes and understanding their differences is crucial for writing clean, expressive, and efficient code. In this section, we will discuss the differences between map() and flatMap() in Java 8.

map(): Transforming Elements in a Stream:

The map() operation is used for transforming elements within a stream. It applies a given function to each element, producing a new stream of transformed elements.

Example:

List<String> words = Arrays.asList("Java", "is", "awesome");
List<String> uppercasedWords = words.stream()
                                  .map(String::toUpperCase)
                                  .collect(Collectors.toList());

In this example, map() is used to convert each word in the stream to uppercase.

flatMap(): Flattening Nested Structures:

The flatMap() operation is more powerful and is primarily used when dealing with nested structures, such as a stream of lists or a stream of optional values. It not only transforms elements but also flattens the resulting stream of streams (or other nested structures) into a single stream.

Example:

List<List<Integer>> numbers = Arrays.asList(
    Arrays.asList(1, 2, 3),
    Arrays.asList(4, 5, 6),
    Arrays.asList(7, 8, 9)
);
List<Integer> flattenedNumbers = numbers.stream()
                                       .flatMap(List::stream)
                                       .collect(Collectors.toList());

Here, flatMap() is used to flatten a list of lists into a single list of integers.

map() Vs. flatMap() in Java 8

Feature	map()	flatMap()
Purpose	Transforming elements in a stream.	Flattening nested structures in a stream.
Transformation	Function One-to-one transformation.	Can produce a stream or another structure.
Output Size	Predictable (1:1 with input size).	Variable, depends on the transformation.
Use Case	Unary transformations.	Dealing with nested structures.
Suitability	Stateless transformations.	Stateful transformations, variable output.
Performance	Predictable output size.	Variable output size, potentially higher complexity.

Use Cases:

map(): Unary Transformations:

Use map() when we want to apply a one-to-one transformation to each element in the stream.

It is suitable for scenarios where the transformation function does not return a stream or another complex structure.

flatMap(): Dealing with Nested Structures:

Use flatMap() when dealing with scenarios where the transformation function returns a stream or a structure that we want to flatten.

It is particularly useful for scenarios involving optional values, where we want to filter out empty optional.

Advanced Use Cases:

map(): Stateless Transformations:

map() is often used for stateless transformations where each element is transformed independently of the others.

flatMap(): Stateful Transformations:

flatMap() is powerful for stateful transformations or scenarios where each element is transformed into a variable number of elements.

Performance Considerations:

map(): Predictable Output Size:

Since map() produces a one-to-one transformation, the output size is predictable and corresponds to the size of the input stream.

flatMap(): Variable Output Size:

flatMap() can produce a variable number of elements for each input element. It makes it more suitable for scenarios where the transformation may result in different sizes of output.

Java map() Example

MapExample.java

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class MapExample {
    public static void main(String[] args) {
        // Input data
        List<String> words = Arrays.asList("Java", "is", "awesome");
        // Using map to transform each element to uppercase
        List<String> uppercasedWords = words.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        // Output
        System.out.println("Original words: " + words);
        System.out.println("Uppercased words: " + uppercasedWords);
    }
}

Output:

Original words: [Java, is, awesome]
Uppercased words: [JAVA, IS, AWESOME]

Java flatMap() Example

FlatMapExample.java

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class FlatMapExample {
    public static void main(String[] args) {
        // Input data - List of Lists
        List<List<Integer>> numbers = Arrays.asList(
                Arrays.asList(1, 2, 3),
                Arrays.asList(4, 5, 6),
                Arrays.asList(7, 8, 9)
        );
        // Using flatMap to flatten the list of lists into a single list of integers
        List<Integer> flattenedNumbers = numbers.stream()
                .flatMap(List::stream)
                .collect(Collectors.toList());
        // Output
        System.out.println("Original list of lists: " + numbers);
        System.out.println("Flattened list of integers: " + flattenedNumbers);
    }
}

Output:

Original list of lists: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Flattened list of integers: [1, 2, 3, 4, 5, 6, 7, 8, 9]

In the map example, the toUpperCase() method is applied to each element of the stream, transforming it to uppercase.

In the flatMap() example, flatMap() is used to flatten the list of lists into a single list of integers.

While both map() and flatMap() are essential tools in the functional programming toolkit of Java 8, they serve distinct purposes. Understanding when to use map() for simple transformations and when to leverage the power of flatMap() for dealing with nested structures is key to writing expressive and efficient code. Mastery of these operations empowers developers to harness the full potential of the Stream API in Java 8 and beyond.

Next TopicDifference Between next() and nextLine() Methods in Java

← prev next →