Difference Between map() And flatMap() In Java Stream

What is flatMap() Method?

The stream flatMap function returns a stream containing the contents of a mapped stream formed by applying a mapping function to each element in the original stream.

Upon placing its contents into this stream, each mapped stream is shut down. A stream that contains nothing is utilized in its place if a mapped stream is null.

Syntax:

For Stream

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)

You can also try this code with Online Java Compiler

Run Code

Since we can't flatten our string using a map, we may use flatMap() when we need to flatten or change the string () which is a prominent difference between map() and flatmap(). 

flatMap() = map() + Flattening. A flatMap() combines two operations; transformation and flattening of a stream of values into another stream that only consists of a single list storing values.

For Optional

public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper)

The flatMap() function on Optional applies a given function to the value in the Optional if it's present, and returns a new Optional that is the result of the flattened stream. If the original Optional is empty, the flatMap() function returns an empty Optional.

Usage and Example

Getting the 1st character of all the strings present in a list of strings and returning the result in the form of a stream.

Implementation

• Java

Java

import java.util.*; 
import java.util.stream.Collectors; 
public class main 
{    
    public static void main(String[] args) 
    {    
        List<Integer> Number1 = Arrays.asList(1, 3, 5, 7); 
        List<Integer> Number2 = Arrays.asList(2, 4, 6, 8); 
        List<List<Integer>> ListofInts = Arrays.asList(Number1, Number2); 
        System.out.println("Before: " + ListofInts); 
        List<Integer> listofInts = ListofInts.stream() .flatMap(list -> list.stream()) .collect(Collectors.toList()); 
        System.out.println("After: " + listofInts); 
    } 
} 

You can also try this code with Online Java Compiler

Run Code

Output:

Before: [[1, 3, 5, 7], [2, 4, 6, 8]]
After: [1, 3, 5, 7, 2, 4, 6, 8] 

You can also try this code with Online Java Compiler

Run Code

Description

This Java code demonstrates how to use the flatMap() method of the Stream class to convert a list of lists into a single list.

First, two lists of integers are created using the Arrays.asList() method. These lists are then stored in another list called ListofInts, which is a list of lists.

Next, the flatMap() method is called on ListofInts. This method flattens the list of lists into a single stream of integers by first calling the stream() method on each list in ListofInts, and then flattening the resulting streams into a single stream of integers. The resulting stream is then collected into a list using the Collectors.toList() method.

Finally, the original ListofInts and the flattened list listofInts are printed to the console.

Also see, Morris Traversal for Inorder.

Difference Between map() and flatmap()

The Difference between map() and flatmap() can be stated as follows:

Java Programs using map() function

• Java

Java

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;

public class MapExample {
    public static <T, R> List<R> map(List<T> list, Function<T, R> mapper) {
        List<R> result = new ArrayList<>(list.size());
        for (T item : list) {
            R mappedItem = mapper.apply(item);
            result.add(mappedItem);
        }
        return result;
    }

    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5);
        List<Integer> squaredNumbers = map(numbers, x -> x * x);
        System.out.println(squaredNumbers); // prints [1, 4, 9, 16, 25]
    }
}

You can also try this code with Online Java Compiler

Run Code

Output:

[1, 4, 9, 16, 25]

Java Programs using flatMap() function

• Java

Java

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

public class FlatMapExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("Hello", "World");

        List<String> letters = words.stream()
                .flatMap(word -> Arrays.stream(word.split("")))
                .collect(Collectors.toList());

        System.out.println(letters);
    }
}

You can also try this code with Online Java Compiler

Run Code

Output:

[H, e, l, l, o, W, o, r, l, d]

Frequently Asked Questions 

Why use flatMap instead of map?

The flatMap() function is used instead of map() when the transformation applied to each element of a collection returns another collection, and we want to flatten the resulting collection of collections into a single collection. 

What is the difference between map and flatMap and a good use case for each?

`map` transforms each element in a stream into another form individually, while `flatMap` transforms each element into a stream and flattens the result. Use `map` for one-to-one transformations and `flatMap` for one-to-many transformations, such as flattening nested collections.

What is the difference between flat map and map C++?

In C++, the map function applies a given function to each element in a collection and returns a new collection of the same size. In contrast, the flat_map function first applies a function to each element in a collection, then flattens the resulting nested collections into a single stream.

Conclusion 

In this blog, we have discussed the difference between flatmap and map functions with some examples to understand their workings.

If you think this blog has helped you enhance your knowledge about the above question, and if you want to learn more, check out our articles:

Recommended Readings:

1. Difference Between Hashmap And Linkedhashmap
2. Difference between HashMap and TreeMap

3. logic for programming

4 Internal Working of HashMap 

5. Difference Between IOT and M2M

And many more on our website.

Refer to our Guided Paths on Coding Ninjas Studio to learn more about DSA, Competitive Programming, C++, JavaScript, System Design, etc. Enroll in our courses and refer to the mock test and problems available; look at the Problem Sheets,  interview experiences, and interview bundle for placement preparations. You can also book an interview session with us.