Java 8 – How to Use map and flatMap in Streams

Introduction

Java 8 introduced the Stream API, which provides a functional approach to processing collections of data. Two powerful operations in the Stream API are map and flatMap. These methods allow you to transform and flatten streams, respectively, making them essential tools for working with complex data structures.

In this guide, we’ll explore how to use the map and flatMap methods in Java 8 streams, covering their usage, differences, and common scenarios.

Table of Contents

• Problem Statement
• Solution Steps
• Java Program
  • Example 1: Using map to Transform Elements
  • Example 2: Using flatMap to Flatten Nested Structures
  • Example 3: Difference Between map and flatMap
  • Example 4: Combining map and flatMap
• Conclusion

Problem Statement

When working with collections, you often need to transform data from one form to another or flatten nested data structures. The map method is used to transform elements in a stream, while flatMap is used to flatten nested collections or streams into a single stream.

Example:

• Problem: Transforming and flattening collections of data efficiently.
• Goal: Use map to transform elements and flatMap to flatten nested structures in a clean and efficient way.

Solution Steps

1. Transform Elements with map: Learn how to use map to apply a function to each element in a stream.
2. Flatten Nested Structures with flatMap: Use flatMap to combine multiple streams or collections into a single stream.
3. Understand the Difference: Compare map and flatMap to understand when to use each.
4. Combine Operations: Explore how to combine map and flatMap for more complex data processing.

Java Program

Example 1: Using map to Transform Elements

The map method applies a function to each element in the stream and returns a new stream of the transformed elements.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Java 8 - Using map to Transform Elements
 * Author: https://www.rameshfadatare.com/
 */
public class MapExample1 {

    public static void main(String[] args) {
        List<String> names = Arrays.asList("Amit", "Priya", "Raj");

        // Transform names to uppercase using map
        List<String> upperCaseNames = names.stream()
                                           .map(String::toUpperCase)
                                           .collect(Collectors.toList());

        System.out.println("Uppercase Names: " + upperCaseNames);
    }
}

Output

Uppercase Names: [AMIT, PRIYA, RAJ]

Explanation

• map(String::toUpperCase): Converts each name in the list to uppercase using the toUpperCase method. The map method transforms each element in the stream and returns a new stream with the transformed elements.

Example 2: Using flatMap to Flatten Nested Structures

The flatMap method is used to flatten nested collections or streams into a single stream.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Java 8 - Using flatMap to Flatten Nested Structures
 * Author: https://www.rameshfadatare.com/
 */
public class FlatMapExample2 {

    public static void main(String[] args) {
        List<List<String>> nestedList = Arrays.asList(
            Arrays.asList("Amit", "Priya"),
            Arrays.asList("Raj", "Suman"),
            Arrays.asList("Kiran", "Nisha")
        );

        // Flatten the nested list using flatMap
        List<String> flattenedList = nestedList.stream()
                                               .flatMap(List::stream)
                                               .collect(Collectors.toList());

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

Output

Flattened List: [Amit, Priya, Raj, Suman, Kiran, Nisha]

Explanation

• flatMap(List::stream): Converts each nested list into a stream and then flattens these streams into a single stream of elements. This operation combines the nested lists into one continuous stream of elements.

Example 3: Difference Between map and flatMap

Let’s compare map and flatMap to highlight their differences.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Java 8 - Difference Between map and flatMap
 * Author: https://www.rameshfadatare.com/
 */
public class MapFlatMapExample3 {

    public static void main(String[] args) {
        List<String> sentences = Arrays.asList("Hello world", "Java 8 streams");

        // Using map to transform elements
        List<String[]> mappedList = sentences.stream()
                                             .map(sentence -> sentence.split(" "))
                                             .collect(Collectors.toList());

        // Using flatMap to flatten the result
        List<String> flatMappedList = sentences.stream()
                                               .flatMap(sentence -> Arrays.stream(sentence.split(" ")))
                                               .collect(Collectors.toList());

        System.out.println("Mapped List: " + Arrays.deepToString(mappedList.toArray()));
        System.out.println("FlatMapped List: " + flatMappedList);
    }
}

Output

Mapped List: [[Hello, world], [Java, 8, streams]]
FlatMapped List: [Hello, world, Java, 8, streams]

Explanation

• map(): Transforms each sentence into an array of words, resulting in a list of string arrays.
• flatMap(): Flattens the arrays into a single stream of words, producing a list of individual words.

Example 4: Combining map and flatMap

You can combine map and flatMap for more complex data processing. For instance, you might first map elements to some intermediate form and then flatten the results.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Java 8 - Combining map and flatMap
 * Author: https://www.rameshfadatare.com/
 */
public class MapFlatMapExample4 {

    public static void main(String[] args) {
        List<String> sentences = Arrays.asList("Hello world", "Java 8 streams");

        // Combining map and flatMap to transform and flatten
        List<String> words = sentences.stream()
                                      .map(sentence -> sentence.split(" "))
                                      .flatMap(Arrays::stream)
                                      .map(String::toUpperCase)
                                      .collect(Collectors.toList());

        System.out.println("Transformed and Flattened List: " + words);
    }
}

Output

Transformed and Flattened List: [HELLO, WORLD, JAVA, 8, STREAMS]

Explanation

• map(sentence -> sentence.split(" ")): First, the sentences are split into arrays of words.
• flatMap(Arrays::stream): These arrays are then flattened into a single stream of words.
• map(String::toUpperCase): Finally, the words are converted to uppercase.

Conclusion

The map and flatMap methods are essential tools in the Java 8 Stream API for transforming and flattening data. Use map when you need to apply a transformation to each element in a stream and flatMap when you need to flatten nested structures into a single stream. Understanding the differences and how to combine these methods allows you to handle complex data processing tasks more effectively and write cleaner, more concise code.