Java LongStream flatMap() Method

The flatMap() method in Java, part of the java.util.stream.LongStream interface, is used to map each element of the stream to a LongStream, and then flatten the resulting streams into a single stream.

Table of Contents

1. Introduction
2. flatMap() Method Syntax
3. Understanding flatMap()
4. Examples
   • Basic Usage
   • Using flatMap() with a List of Arrays
5. Real-World Use Case
6. Conclusion

Introduction

The flatMap() method allows you to transform each element of a stream into another stream, and then flatten the resulting streams into a single stream. This is useful for scenarios where you need to process nested structures or expand each element into multiple elements.

flatMap() Method Syntax

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

LongStream flatMap(LongFunction<? extends LongStream> mapper)

Parameters:

• mapper: A function that maps each element of the stream to a LongStream.

Returns:

• A new LongStream that is the result of flattening the streams produced by applying the mapper function to each element of the original stream.

Throws:

• This method does not throw any exceptions.

Understanding flatMap()

The flatMap() method takes a function that maps each element of the stream to another LongStream. It then flattens these streams into a single stream, effectively combining the elements of all the produced streams into one continuous stream.

Examples

Basic Usage

To demonstrate the basic usage of flatMap(), we will create a LongStream and use flatMap() to expand each element into multiple elements.

Example

import java.util.stream.LongStream;

public class FlatMapExample {
    public static void main(String[] args) {
        LongStream stream = LongStream.of(1L, 2L, 3L);

        // Use flatMap() to expand each element into a range of elements
        LongStream flatMappedStream = stream.flatMap(n -> LongStream.of(n, n * 2, n * 3));

        // Print the elements of the flattened stream
        flatMappedStream.forEach(System.out::println);
    }
}

Output:

1
2
3
2
4
6
3
6
9

Using flatMap() with a List of Arrays

This example shows how to use flatMap() to process a stream of arrays and flatten them into a single stream of elements.

Example

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

public class FlatMapArrayExample {
    public static void main(String[] args) {
        List<long[]> listOfArrays = Arrays.asList(
            new long[]{1L, 2L, 3L},
            new long[]{4L, 5L},
            new long[]{6L, 7L, 8L, 9L}
        );

        // Use flatMap() to flatten the stream of arrays into a single stream
        LongStream flatMappedStream = listOfArrays.stream().flatMapToLong(LongStream::of);

        // Print the elements of the flattened stream
        flatMappedStream.forEach(System.out::println);
    }
}

Output:

1
2
3
4
5
6
7
8
9

Real-World Use Case

Flattening Transaction Details

In real-world applications, the flatMap() method can be used to flatten transaction details where each transaction contains multiple items, and you want to create a single stream of all items across all transactions.

Example

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

public class FlatMapTransactionExample {
    static class Transaction {
        long id;
        long[] itemIds;

        Transaction(long id, long[] itemIds) {
            this.id = id;
            this.itemIds = itemIds;
        }

        LongStream getItemIds() {
            return LongStream.of(itemIds);
        }
    }

    public static void main(String[] args) {
        List<Transaction> transactions = Arrays.asList(
            new Transaction(1L, new long[]{101L, 102L, 103L}),
            new Transaction(2L, new long[]{201L, 202L}),
            new Transaction(3L, new long[]{301L, 302L, 303L, 304L})
        );

        // Use flatMap() to flatten the item IDs of all transactions into a single stream
        LongStream allItemIds = transactions.stream().flatMapToLong(Transaction::getItemIds);

        // Print the item IDs
        allItemIds.forEach(System.out::println);
    }
}

Output:

101
102
103
201
202
301
302
303
304

Conclusion

The LongStream.flatMap() method is used to map each element of the stream to a LongStream, and then flatten the resulting streams into a single stream. This method is particularly useful for processing nested structures or expanding each element into multiple elements. By understanding and using this method, you can efficiently manage and process streams of values in your Java applications, ensuring that complex data structures are flattened and processed as needed.