Java 8 introduced streams as a way to process data in a functional and efficient manner. One of the key concepts of streams is the ability to perform aggregate operations, such as filtering, mapping, and reducing. In this article, we will focus on two of these operations: map() and flatMap().

Java8 map() vs flatMap():

The map() operation takes an input stream and transforms each element in the stream into a new element. For example, you might use map() to convert a stream of strings into a stream of integers. The resulting stream will contain the same number of elements as the input stream, but each element will have been transformed in some way.

On the other hand, the flatMap() operation takes an input stream and produces a new stream that is formed by flattening the result of the map() operation. For example, you might use flatMap() to convert a stream of lists into a stream of individual elements. The resulting stream will contain a potentially larger number of elements than the input stream, as each list in the input stream will be expanded into its individual elements.

The key difference between map() and flatMap() is the type of stream that they produce. map() produces a stream of the same type as the input stream, while flatMap() produces a stream of a different type. This difference has implications for the type of operations that you can perform on the streams and for the efficiency of the operations.

Difference between map() and flatMap():

In general, you should use map() when you want to perform a simple transformation on each element in the stream, and flatMap() when you want to produce a stream that contains elements from multiple sources.

Here’s an example to help illustrate the difference between map() and flatMap().

Suppose you have a list of lists of integers, and you want to produce a stream of all the integers in the lists. You could use the map() operation to produce a stream of lists, and then use the flatMap() operation to produce a stream of integers.

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

public class MapFlatMap {
    public static void main(String[] args) {
        List<List<Integer>> listOfLists = Arrays.asList(Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 6));
        Stream<List<Integer>> listStream = listOfLists.stream().map(list -> list);
        Stream<Integer> intStream = listStream.flatMap(list -> list.stream());
        System.out.println(intStream);
        intStream.forEach(System.out::println);
    }
}

Output:

1
2
3
4
5
6

In the above example, the map() operation produces a stream of lists, and the flatMap() operation produces a stream of integers. The resulting stream contains all the integers in the original list of lists.

Whare should we use map() and faltMap():

While both methods allow you to modify the elements in a stream, they work differently and have distinct use cases. Understanding the differences between the two methods can help you choose the appropriate method for your needs.

Here’s a comparison of map() and flatMap():

In conclusion, map() is best used for transforming a stream into another stream with the same number of elements, whereas flatMap() is ideal for transforming a stream into a stream with a different number of elements and combining multiple streams into a single stream.

References:

• Java8 map() doc

Happy Learning 🙂