Java Stream mapMulti() Method

The mapMulti() method in Java, introduced in JDK 16, is a powerful method of the Stream interface that allows more complex and flexible mappings of elements. It enables you to map each element of the stream to multiple elements, providing more control compared to flatMap().

Table of Contents

1. Introduction
2. mapMulti() Method Syntax
3. Understanding mapMulti()
4. Examples
   • Basic Usage
   • Using mapMulti() with Complex Transformations
5. Real-World Use Case
6. Conclusion

Introduction

The mapMulti() method allows you to perform a one-to-many mapping of elements, where each element of the original stream can be mapped to zero or more elements. This method is particularly useful for scenarios where you need to produce a dynamic number of results for each input element.

mapMulti() Method Syntax

The syntax for the mapMulti() method is as follows:

<R> Stream<R> mapMulti(BiConsumer<? super T, ? super Consumer<R>> mapper)

Parameters:

• mapper: A BiConsumer that consumes an element of the stream and a Consumer to which multiple elements can be passed.

Returns:

• A new Stream consisting of the mapped elements.

Throws:

• This method does not throw any exceptions.

Understanding mapMulti()

The mapMulti() method allows you to take each element of the original stream and produce multiple elements for the resulting stream. This is achieved by using a BiConsumer that processes each element and calls a provided Consumer for each resulting element.

Examples

Basic Usage

To demonstrate the basic usage of mapMulti(), we will create a Stream of integers and use mapMulti() to map each integer to its square and cube.

Example

import java.util.stream.Stream;

public class MapMultiExample {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3);

        // Use mapMulti() to map each integer to its square and cube
        Stream<Integer> mappedStream = stream.mapMulti((number, consumer) -> {
            consumer.accept(number * number); // Square
            consumer.accept(number * number * number); // Cube
        });

        // Print the mapped elements
        mappedStream.forEach(System.out::println);
    }
}

Output:

1
1
4
8
9
27

Using mapMulti() with Complex Transformations

This example shows how to use mapMulti() to split a stream of sentences into a stream of words.

Example

import java.util.stream.Stream;

public class MapMultiComplexExample {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("Hello world", "How are you");

        // Use mapMulti() to split sentences into words
        Stream<String> wordStream = stream.mapMulti((sentence, consumer) -> {
            for (String word : sentence.split(" ")) {
                consumer.accept(word);
            }
        });

        // Print the mapped elements
        wordStream.forEach(System.out::println);
    }
}

Output:

Hello
world
How
are
you

Real-World Use Case

Expanding Hierarchical Data

In real-world applications, the mapMulti() method can be used to expand hierarchical data structures, such as expanding a stream of directories into a stream of files.

Example

import java.io.File;
import java.util.stream.Stream;

public class MapMultiFileExample {
    public static void main(String[] args) {
        Stream<File> directories = Stream.of(new File("dir1"), new File("dir2"));

        // Use mapMulti() to expand directories into files
        Stream<File> fileStream = directories.mapMulti((directory, consumer) -> {
            File[] files = directory.listFiles();
            if (files != null) {
                for (File file : files) {
                    consumer.accept(file);
                }
            }
        });

        // Print the mapped elements (files)
        fileStream.forEach(System.out::println);
    }
}

Output:

(Note: The actual output will depend on the contents of the directories.)

Conclusion

The Stream.mapMulti() method is used for performing one-to-many mappings of elements in a stream. This method is particularly useful for scenarios where you need to produce a dynamic number of results for each input element. By understanding and using this method, you can efficiently manage and process streams of values in your Java applications, allowing for flexible and complex data transformations.