Java DoubleStream mapToInt() Method

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

Table of Contents

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

Introduction

The mapToInt() method returns an IntStream consisting of the results of applying a given function to the elements of the original DoubleStream. 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(DoubleToIntFunction mapper)

Parameters:

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

Returns:

• An IntStream consisting of the results of applying the given function to the elements of the original DoubleStream.

Throws:

• This method does not throw any exceptions.

Understanding mapToInt()

The mapToInt() method allows you to transform the elements of a DoubleStream by applying a specified function to each element. The resulting stream contains the transformed elements as int values, preserving the order of the original stream.

Examples

Basic Usage

To demonstrate the basic usage of mapToInt(), we will create a DoubleStream and use mapToInt() to convert each element to its integer part.

Example

import java.util.stream.DoubleStream;
import java.util.stream.IntStream;

public class MapToIntExample {
    public static void main(String[] args) {
        DoubleStream doubleStream = DoubleStream.of(1.1, 2.2, 3.3, 4.4, 5.5);

        // Apply a function to convert each element to its integer part
        IntStream intStream = doubleStream.mapToInt(n -> (int) n);

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

Output:

1
2
3
4
5

Using mapToInt() with Custom Transformation

This example shows how to use mapToInt() to transform a DoubleStream into an IntStream by applying a custom transformation. In this case, we will multiply each element by 10 and convert it to an integer.

Example

import java.util.stream.DoubleStream;
import java.util.stream.IntStream;

public class CustomTransformationExample {
    public static void main(String[] args) {
        DoubleStream doubleStream = DoubleStream.of(1.1, 2.2, 3.3, 4.4, 5.5);

        // Apply a custom function to multiply each element by 10 and convert to int
        IntStream intStream = doubleStream.mapToInt(n -> (int) (n * 10));

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

Output:

11
22
33
44
55

Real-World Use Case

Converting Sensor Readings to Integer Units

In real-world applications, the mapToInt() method can be used to convert sensor readings from double values to integer units for further processing or storage.

Example

import java.util.stream.DoubleStream;
import java.util.stream.IntStream;

public class SensorDataConversionExample {
    public static void main(String[] args) {
        DoubleStream sensorData = DoubleStream.of(25.3, 26.7, 24.8, 27.5, 30.1);

        // Convert the sensor readings to integer units
        IntStream intSensorData = sensorData.mapToInt(reading -> (int) reading);

        // Print the converted sensor readings
        intSensorData.forEach(intReading -> System.out.println("Integer sensor reading: " + intReading));
    }
}

Output:

Integer sensor reading: 25
Integer sensor reading: 26
Integer sensor reading: 24
Integer sensor reading: 27
Integer sensor reading: 30

Conclusion

The DoubleStream.mapToInt() method is used to apply a given function to each element of the stream, producing an IntStream with the results of the applied function. This method is particularly useful for transforming the elements of a DoubleStream into int values. By understanding and using this method, you can efficiently manage and manipulate streams of double values in your Java applications.