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
doubletoint, such as truncation, rounding, or scaling computations. - To streamline operations on numeric streams (e.g., from
DoubleStreamtoIntStream). - 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.