Java LongStream mapToInt() Method

The mapToInt() method in Java, part of the java.util.stream.LongStream interface, is used to apply a given function to each element of the stream, producing a new IntStream of the results. This method is useful when you need to transform the elements of a LongStream into int values.

Table of Contents

1. Introduction
2. mapToInt() Method Syntax
3. Understanding mapToInt()
4. Examples
   • Basic Usage
   • Using mapToInt() with a Custom Function
5. Real-World Use Case
6. Conclusion

Introduction

The mapToInt() method transforms each element of a LongStream by applying a specified function to it, resulting in a new IntStream of transformed elements. This method is an intermediate operation, meaning it returns a new stream and does not modify the original stream.

mapToInt() Method Syntax

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

IntStream mapToInt(LongToIntFunction mapper)

Parameters:

• mapper: A LongToIntFunction that represents the function to be applied to each element of the stream.

Returns:

• A new IntStream consisting of the results of applying the given function to the elements of the original stream.

Throws:

• This method does not throw any exceptions.

Understanding mapToInt()

The mapToInt() method allows you to transform each element of a LongStream into an int by applying a specified function to it. The resulting stream contains the transformed int elements, each of which is the result of applying the function to the corresponding element in the original stream.

Examples

Basic Usage

To demonstrate the basic usage of mapToInt(), we will create a LongStream and use mapToInt() to convert each element to its remainder when divided by a specified number.

Example

import java.util.stream.IntStream;
import java.util.stream.LongStream;

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

        // Use mapToInt() to get the remainder when each element is divided by 2
        IntStream intStream = stream.mapToInt(n -> (int) (n % 2));

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

Output:

1
0
1
0
1

Using mapToInt() with a Custom Function

This example shows how to use mapToInt() with a custom function to transform each element of the stream.

Example

import java.util.stream.IntStream;
import java.util.stream.LongStream;

public class MapToIntCustomFunctionExample {
    public static void main(String[] args) {
        LongStream stream = LongStream.of(10L, 20L, 30L, 40L, 50L);

        // Use mapToInt() with a custom function to convert each element to its half value as an int
        IntStream intStream = stream.mapToInt(n -> (int) (n / 2));

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

Output:

5
10
15
20
25

Real-World Use Case

Converting Transaction Amounts to Integer Values

In real-world applications, the mapToInt() method can be used to convert transaction amounts from long to int for cases where you need integer representations of the amounts.

Example

import java.util.stream.IntStream;
import java.util.stream.LongStream;

public class MapToIntTransactionsExample {
    public static void main(String[] args) {
        LongStream transactionAmounts = LongStream.of(1000L, 2000L, 1500L, 3000L, 2500L);

        // Use mapToInt() to convert transaction amounts from long to int
        IntStream intTransactionAmounts = transactionAmounts.mapToInt(amount -> (int) (amount / 1000));

        // Print the integer transaction amounts
        intTransactionAmounts.forEach(amount -> System.out.println("Transaction Amount (in thousands): " + amount));
    }
}

Output:

Transaction Amount (in thousands): 1
Transaction Amount (in thousands): 2
Transaction Amount (in thousands): 1
Transaction Amount (in thousands): 3
Transaction Amount (in thousands): 2

Conclusion

The LongStream.mapToInt() method is used to apply a given function to each element of the stream, producing a new IntStream of the results. This method is particularly useful for transforming the elements of a LongStream into int values. By understanding and using this method, you can efficiently manage and process streams of values in your Java applications, ensuring that each element is transformed as needed.