Java LongStream mapToDouble() Method

The mapToDouble() 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 DoubleStream of the results. This method is useful when you need to transform the elements of a LongStream into double values.

Table of Contents

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

Introduction

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

mapToDouble() Method Syntax

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

DoubleStream mapToDouble(LongToDoubleFunction mapper)

Parameters:

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

Returns:

• A new DoubleStream 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 mapToDouble()

The mapToDouble() method allows you to transform each element of a LongStream into a double by applying a specified function to it. The resulting stream contains the transformed double 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 mapToDouble(), we will create a LongStream and use mapToDouble() to convert each element to its square root.

Example

import java.util.stream.DoubleStream;
import java.util.stream.LongStream;

public class MapToDoubleExample {
    public static void main(String[] args) {
        LongStream stream = LongStream.of(1L, 4L, 9L, 16L, 25L);

        // Use mapToDouble() to compute the square root of each element
        DoubleStream sqrtStream = stream.mapToDouble(Math::sqrt);

        // Print the elements of the DoubleStream
        sqrtStream.forEach(System.out::println);
    }
}

Output:

1.0
2.0
3.0
4.0
5.0

Using mapToDouble() with a Custom Function

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

Example

import java.util.stream.DoubleStream;
import java.util.stream.LongStream;

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

        // Use mapToDouble() with a custom function to convert each element to its half value
        DoubleStream halfStream = stream.mapToDouble(n -> n / 2.0);

        // Print the elements of the DoubleStream
        halfStream.forEach(System.out::println);
    }
}

Output:

5.0
10.0
15.0
20.0
25.0

Real-World Use Case

Converting Transaction Amounts to Dollars

In real-world applications, the mapToDouble() method can be used to convert transaction amounts from one currency to another, such as converting cents to dollars.

Example

import java.util.stream.DoubleStream;
import java.util.stream.LongStream;

public class MapToDoubleTransactionsExample {
    public static void main(String[] args) {
        LongStream transactionAmountsInCents = LongStream.of(10000L, 20000L, 15000L, 30000L, 25000L);

        // Use mapToDouble() to convert transaction amounts from cents to dollars
        DoubleStream transactionAmountsInDollars = transactionAmountsInCents.mapToDouble(amount -> amount / 100.0);

        // Print the transaction amounts in dollars
        transactionAmountsInDollars.forEach(amount -> System.out.println("Transaction Amount: $" + amount));
    }
}

Output:

Transaction Amount: $100.0
Transaction Amount: $200.0
Transaction Amount: $150.0
Transaction Amount: $300.0
Transaction Amount: $250.0

Conclusion

The LongStream.mapToDouble() method is used to apply a given function to each element of the stream, producing a new DoubleStream of the results. This method is particularly useful for transforming the elements of a LongStream into double 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.