The DoubleToIntFunction interface in Java, part of the java.util.function package, represents a function that accepts a single double-valued argument and produces an int-valued result. It can be used when a conversion or computation needs to be performed from a double type to an int.

Functional Interface

The DoubleToIntFunction interface is annotated with @FunctionalInterface, meaning it has a single abstract method:

int applyAsInt(double value);

How to Use DoubleToIntFunction

1. Using a Lambda Expression

The most common way to use DoubleToIntFunction is by defining logic for the applyAsInt method using a lambda expression.

Here’s an example:

package org.kodejava.util.function;

import java.util.function.DoubleToIntFunction;

public class DoubleToIntFunctionExample {
    public static void main(String[] args) {
        // Define a DoubleToIntFunction to truncate a double to an int
        DoubleToIntFunction truncateFunction = value -> (int) value;

        // Apply the function
        // Outputs: 42
        System.out.println("Truncated value: " + truncateFunction.applyAsInt(42.75));
    }
}

2. Defining Custom Logic

We can use DoubleToIntFunction to define custom logic for converting a double to an int. For example, calculating a percentage or applying a formula.

package org.kodejava.util.function;

import java.util.function.DoubleToIntFunction;

public class CustomLogicExample {
    public static void main(String[] args) {
        // Convert double temperature from Celsius to a truncated Fahrenheit value
        DoubleToIntFunction celsiusToFahrenheit =
                celsius -> (int) ((celsius * 9 / 5) + 32);

        // Convert and print the result
        // Outputs: 97
        System.out.println("Temperature in Fahrenheit: " +
                           celsiusToFahrenheit.applyAsInt(36.6));
    }
}

3. Using with Streams

DoubleToIntFunction can be useful in combination with primitive streams, such as DoubleStream, where we need to map a double value to an int.

Example:

package org.kodejava.util.function;

import java.util.stream.DoubleStream;

public class StreamWithDoubleToIntFunction {
    public static void main(String[] args) {
        // Create a DoubleStream
        DoubleStream doubleStream = DoubleStream.of(12.3, 45.6, 78.9);

        // Use DoubleToIntFunction to convert each double to an int
        doubleStream.mapToInt(value -> (int) value)
                .forEach(System.out::println);
        // Outputs:
        // 12
        // 45
        // 78
    }
}

4. Combined with Other Functional Interfaces

We can combine DoubleToIntFunction with other functional interfaces for more complex transformations.

package org.kodejava.util.function;

import java.util.function.DoubleToIntFunction;
import java.util.function.IntConsumer;

public class CombinedFunctionExample {
    public static void main(String[] args) {
        // DoubleToIntFunction to convert double to int
        DoubleToIntFunction conversionFunction = value -> (int) (value * 100);

        // IntConsumer to process the int (e.g., print it)
        IntConsumer printConsumer = result -> System.out.println("Processed value: " + result);

        // Apply the function and consume the result
        double inputValue = 4.56789;
        printConsumer.accept(conversionFunction.applyAsInt(inputValue));
        // Output: Processed value: 456
    }
}

When to Use DoubleToIntFunction

• When working with conversions or mappings from double to int, such as truncation, rounding, or scaling computations.
• To streamline operations on numeric streams (e.g., from DoubleStream to IntStream).
• In functional programming scenarios where transformations are required.

Summary

The DoubleToIntFunction is a useful tool for converting or mapping double values to int in a concise and functional way. It integrates well with Java streams and other functional interfaces, making it ideal for scenarios involving mathematical operations, data processing, or formatting.