How to Use the flatMap Method with Collections in Java?

Understanding the flatMap Method

The flatMap method is a part of the Stream interface, introduced in Java 8. It is used to transform and flatten a collection of collections. The key difference between map and flatMap is that map maintains the nested structure, while flatMap flattens it into a single stream.

In simple terms: map allows one-to-one transformations, and flatMap allows one-to-many transformations.

For example, if you have a list of lists and want to combine them into one single list, flatMap comes in handy. This is because it flattens each element of a collection into a single stream, as opposed to returning nested structures.

Basic Syntax of flatMap

The syntax of the flatMap method looks like this:

Stream flatMap(Function> mapper);
            

Here:

• mapper: a function that produces a stream for each element in the source stream.
• T: the type of elements in the source stream.
• R: the type of elements in the resulting stream.

Let’s take a look at a practical example to understand this better.

Example 1: Using flatMap on a List of Lists

Consider a scenario where you have a list of lists and want to merge them into a single list:

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

public class FlatMapExample {
    public static void main(String[] args) {
        List> listOfLists = Arrays.asList(
            Arrays.asList(1, 2, 3),
            Arrays.asList(4, 5),
            Arrays.asList(6, 7, 8)
        );

        List flatList = listOfLists.stream()
                                           .flatMap(Collection::stream)
                                           .collect(Collectors.toList());

        System.out.println(flatList);  // Output: [1, 2, 3, 4, 5, 6, 7, 8]
    }
}

            

In this example, we have a List>, and we want to flatten it into a single list of integers. Using flatMap, we map each inner list to a stream and then collect the elements into a flat list.

Example 2: Flattening Nested Collections of Strings

Let’s say you have a list of lists of strings, where each string is a sentence, and you want to extract all the words from all sentences:

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

public class FlatMapStringExample {
    public static void main(String[] args) {
        List> sentences = Arrays.asList(
            Arrays.asList("Hello world", "Java is fun"),
            Arrays.asList("FlatMap is awesome", "Streams are powerful")
        );

        List words = sentences.stream()
                                      .flatMap(sentence -> Arrays.stream(sentence.split(" ")))
                                      .collect(Collectors.toList());

        System.out.println(words);  // Output: [Hello, world, Java, is, fun, FlatMap, is, awesome, Streams, are, powerful]
    }
}

            

In this case, we split each sentence into words and then flatten the result into a list of individual words. The flatMap method ensures that the resulting stream is not a stream of arrays, but a stream of words.

Example 3: Applying flatMap with Custom Objects

Now, let’s work with custom objects. Consider a scenario where you have a list of people, and each person has a list of addresses. You want to extract all the addresses:

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

class Person {
    String name;
    List addresses;

    public Person(String name, List addresses) {
        this.name = name;
        this.addresses = addresses;
    }

    public List getAddresses() {
        return addresses;
    }
}

public class FlatMapCustomExample {
    public static void main(String[] args) {
        List people = Arrays.asList(
            new Person("Alice", Arrays.asList("123 Main St", "456 Oak St")),
            new Person("Bob", Arrays.asList("789 Pine St")),
            new Person("Charlie", Arrays.asList("101 Maple St", "202 Birch St"))
        );

        List allAddresses = people.stream()
                                         .flatMap(person -> person.getAddresses().stream())
                                         .collect(Collectors.toList());

        System.out.println(allAddresses);  // Output: [123 Main St, 456 Oak St, 789 Pine St, 101 Maple St, 202 Birch St]
    }
}

            

In this example, we have a List, and each person has a list of addresses. We use flatMap to flatten the list of addresses into a single stream of addresses.

Practical Use Cases of flatMap

Here are a few practical use cases of the flatMap method:

• Flattening nested lists or collections: As shown in the examples, flatMap is useful when you want to flatten a collection of collections.
• Transforming and combining data: You can use flatMap to extract and combine data from nested structures, such as lists of objects.
• Working with optional values: You can use flatMap to transform Optional values, creating a stream without nested Optional objects.
• Handling multiple values from a single object: For example, extracting multiple values (such as tags or keywords) from an object in a database.

Conclusion

The flatMap method is an essential tool in Java’s Stream API for flattening and transforming collections. It is particularly useful when dealing with nested structures, as it flattens the stream into a single one. Whether you’re working with lists of lists or custom objects, flatMap provides a concise and elegant solution.

Understanding how to use flatMap can improve your ability to manipulate complex data structures and make your code more readable and efficient.