Java Stream flatMapToInt() Method

The flatMapToInt() method in Java is a part of the java.util.stream.Stream interface. In this guide, we will learn how to use flatMapToInt() method in Java with practical examples and real-world use cases to better understand its usage.

Table of Contents

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

Introduction

The Stream.flatMapToInt() method in Java transforms each element of a stream into an IntStream. It’s designed to handle primitive int values.

This method is useful when you need to map stream elements to integer values and combine the results into a single IntStream.

flatMapToInt() is commonly used when working with numerical data and helps in processing integers efficiently in a stream pipeline.

flatMapToInt() Method Syntax

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

IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper)

Parameters:

• mapper: A function to apply to each element, which produces an IntStream of new values.

Returns:

• A new IntStream consisting of the flattened results of the mapped streams.

Throws:

• This method does not throw any exceptions.

Examples

Basic Usage

To demonstrate the basic usage of flatMapToInt(), we will create a Stream of arrays of int values and use flatMapToInt() to flatten these arrays into a single IntStream.

Example

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

public class FlatMapToIntExample {
    public static void main(String[] args) {
        Stream<int[]> stream = Stream.of(
            new int[]{1, 2, 3},
            new int[]{4, 5},
            new int[]{6, 7, 8, 9}
        );

        // Use flatMapToInt() to flatten the arrays into a single IntStream
        IntStream intStream = stream.flatMapToInt(Arrays::stream);

        // Print the flattened elements
        intStream.forEach(System.out::println);
    }
}

Output:

1
2
3
4
5
6
7
8
9

Using flatMapToInt() with Complex Transformations

This example shows how to use flatMapToInt() with a more complex transformation to generate multiple int values for each element.

Example

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

public class FlatMapToIntComplexExample {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("1,2,3", "4,5", "6,7,8,9");

        // Use flatMapToInt() to flatten the comma-separated strings into a single IntStream
        IntStream intStream = stream.flatMapToInt(s ->
            IntStream.of(Arrays.stream(s.split(",")).mapToInt(Integer::parseInt).toArray())
        );

        // Print the flattened elements
        intStream.forEach(System.out::println);
    }
}

Output:

1
2
3
4
5
6
7
8
9

Real-World Use Case

Processing Multiple Measurements

In real-world applications, the flatMapToInt() method can be used to process multiple measurements from different sensors, each producing a stream of int values.

Example

import java.util.stream.IntStream;
import java.util.stream.Stream;

public class FlatMapToIntMeasurementsExample {
    static class Sensor {
        String id;
        int[] measurements;

        Sensor(String id, int[] measurements) {
            this.id = id;
            this.measurements = measurements;
        }

        IntStream getMeasurementsStream() {
            return IntStream.of(measurements);
        }
    }

    public static void main(String[] args) {
        Stream<Sensor> sensors = Stream.of(
            new Sensor("Sensor1", new int[]{1, 2, 3}),
            new Sensor("Sensor2", new int[]{4, 5}),
            new Sensor("Sensor3", new int[]{6, 7, 8, 9})
        );

        // Use flatMapToInt() to flatten the measurements into a single IntStream
        IntStream measurementsStream = sensors.flatMapToInt(Sensor::getMeasurementsStream);

        // Print the flattened measurements
        measurementsStream.forEach(System.out::println);
    }
}

Output:

1
2
3
4
5
6
7
8
9

Conclusion

The Stream.flatMapToInt() method is used to transform each element of the stream into an IntStream and then flatten these streams into a single IntStream. This method is particularly useful for handling elements that generate multiple int values.

By understanding and using this method, you can efficiently manage and process streams of values in your Java applications, transforming and flattening complex data structures as needed.