Java ToDoubleFunction Interface
Last modified: April 16, 2025
The java.util.function.ToDoubleFunction interface represents a function
that accepts one argument and produces a double-valued result. It is a functional
interface with a single abstract method applyAsDouble.
ToDoubleFunction is part of Java's functional programming utilities
added in Java 8. It is specialized to avoid boxing when working with primitive
double values. This improves performance in numeric operations.
ToDoubleFunction Interface Overview
ToDoubleFunction interface contains one abstract method that must
be implemented. The method takes an object of type T and returns a primitive
double value. There are no default methods in this interface.
@FunctionalInterface
public interface ToDoubleFunction<T> {
double applyAsDouble(T value);
}
The code above shows the simple structure of ToDoubleFunction. It
uses generics where T is the input type. The interface is annotated with
@FunctionalInterface to indicate its single abstract method nature.
Basic ToDoubleFunction Usage
The simplest way to use ToDoubleFunction is with lambda expressions. We define how to convert the input to a double value. This example calculates string lengths.
package com.zetcode;
import java.util.function.ToDoubleFunction;
public class Main {
public static void main(String[] args) {
// Define function that returns string length as double
ToDoubleFunction<String> lengthFunction = s -> (double) s.length();
// Apply the function
System.out.println("Length of 'hello': " + lengthFunction.applyAsDouble("hello"));
System.out.println("Length of 'functional': " + lengthFunction.applyAsDouble("functional"));
// Using method reference
ToDoubleFunction<String> lengthMethodRef = String::length;
System.out.println("Length via method ref: " + lengthMethodRef.applyAsDouble("method"));
}
}
This example demonstrates basic ToDoubleFunction usage with lambda and method reference. The function takes String and returns its length as double. We apply it to different strings. Method reference provides concise syntax.
ToDoubleFunction with Custom Objects
ToDoubleFunction works well with custom objects. We can extract numeric properties from objects. This example calculates product prices after tax.
package com.zetcode;
import java.util.function.ToDoubleFunction;
class Product {
String name;
double price;
Product(String name, double price) {
this.name = name;
this.price = price;
}
}
public class Main {
public static void main(String[] args) {
// Function to calculate price with 20% tax
ToDoubleFunction<Product> priceWithTax = p -> p.price * 1.20;
Product laptop = new Product("Laptop", 999.99);
Product phone = new Product("Phone", 599.99);
System.out.println("Laptop with tax: " + priceWithTax.applyAsDouble(laptop));
System.out.println("Phone with tax: " + priceWithTax.applyAsDouble(phone));
}
}
This example shows ToDoubleFunction with custom Product objects. The function calculates the final price including tax. We apply it to different product instances. The result is always a primitive double.
ToDoubleFunction in Stream Operations
ToDoubleFunction is commonly used with Java Streams for numeric transformations. The mapToDouble operation accepts a ToDoubleFunction. This enables efficient numeric processing.
package com.zetcode;
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> words = Arrays.asList("apple", "banana", "cherry", "date");
// Calculate average word length
double avgLength = words.stream()
.mapToDouble(String::length) // ToDoubleFunction as method reference
.average()
.orElse(0);
System.out.println("Average word length: " + avgLength);
// Sum of squares of lengths
double sumSquares = words.stream()
.mapToDouble(s -> Math.pow(s.length(), 2)) // Lambda as ToDoubleFunction
.sum();
System.out.println("Sum of squares: " + sumSquares);
}
}
This example demonstrates ToDoubleFunction in Streams. We use method reference and lambda to transform strings to numeric values. The stream operations work with primitive doubles for better performance.
ToDoubleFunction with Collections
ToDoubleFunction can be used with collection operations that require numeric transformations. This example shows statistics calculation on a collection.
package com.zetcode;
import java.util.Arrays;
import java.util.DoubleSummaryStatistics;
import java.util.List;
import java.util.function.ToDoubleFunction;
public class Main {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(10, 20, 30, 40, 50);
// Convert integers to their square roots
ToDoubleFunction<Integer> sqrtFunction = n -> Math.sqrt(n);
DoubleSummaryStatistics stats = numbers.stream()
.mapToDouble(sqrtFunction)
.summaryStatistics();
System.out.println("Count: " + stats.getCount());
System.out.println("Average: " + stats.getAverage());
System.out.println("Max: " + stats.getMax());
System.out.println("Min: " + stats.getMin());
System.out.println("Sum: " + stats.getSum());
}
}
This example uses ToDoubleFunction to calculate square roots of integers. We then generate statistics from the results. The function enables clean numeric transformations before statistical operations.
ToDoubleFunction with Arrays
Arrays can be processed efficiently using ToDoubleFunction. This example shows array transformation and reduction operations.
package com.zetcode;
import java.util.Arrays;
import java.util.function.ToDoubleFunction;
public class Main {
public static void main(String[] args) {
String[] temperatures = {"23.5", "18.2", "31.7", "25.0", "19.8"};
// Parse strings to doubles
ToDoubleFunction<String> parseDouble = s -> Double.parseDouble(s);
double[] values = Arrays.stream(temperatures)
.mapToDouble(parseDouble)
.toArray();
System.out.println("Parsed values: " + Arrays.toString(values));
// Find maximum temperature
double max = Arrays.stream(temperatures)
.mapToDouble(Double::parseDouble) // Method reference alternative
.max()
.orElse(Double.NaN);
System.out.println("Maximum temperature: " + max);
}
}
This example processes an array of temperature strings. We use ToDoubleFunction to parse strings to doubles. The results are collected in an array and used for finding the maximum value. Both lambda and method reference forms are shown.
Combining ToDoubleFunction with Other Functional Interfaces
ToDoubleFunction can be combined with other functional interfaces for more complex operations. This example shows filtering before conversion.
package com.zetcode;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.function.ToDoubleFunction;
public class Main {
public static void main(String[] args) {
List<String> mixedValues = Arrays.asList("12.5", "invalid", "45.2", "0", "3.14");
Predicate<String> isNumeric = s -> {
try {
Double.parseDouble(s);
return true;
} catch (NumberFormatException e) {
return false;
}
};
ToDoubleFunction<String> parseSafe = s -> {
try {
return Double.parseDouble(s);
} catch (NumberFormatException e) {
return 0.0;
}
};
// Filter valid numbers and parse them
double sum = mixedValues.stream()
.filter(isNumeric)
.mapToDouble(parseSafe)
.sum();
System.out.println("Sum of valid numbers: " + sum);
// Alternative with handling in ToDoubleFunction
double sumAlt = mixedValues.stream()
.mapToDouble(parseSafe)
.sum();
System.out.println("Sum with default handling: " + sumAlt);
}
}
This example combines Predicate and ToDoubleFunction to safely process mixed input. We filter valid numbers first, then parse them. An alternative approach handles invalid values within the ToDoubleFunction itself.
Primitive Specializations Comparison
Java provides several primitive-specialized functional interfaces. This example compares ToDoubleFunction with similar interfaces for different primitives.
package com.zetcode;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.function.ToDoubleFunction;
public class Main {
public static void main(String[] args) {
// Different primitive specialized functions
ToIntFunction<String> toLengthInt = String::length;
ToLongFunction<String> toLengthLong = s -> (long) s.length();
ToDoubleFunction<String> toLengthDouble = s -> (double) s.length();
System.out.println("As int: " + toLengthInt.applyAsInt("hello"));
System.out.println("As long: " + toLengthLong.applyAsLong("world"));
System.out.println("As double: " + toLengthDouble.applyAsDouble("java"));
// When precision matters
ToDoubleFunction<Double> circleArea = r -> Math.PI * r * r;
System.out.println("Area of circle with r=2.5: " + circleArea.applyAsDouble(2.5));
}
}
This example compares ToDoubleFunction with ToIntFunction and ToLongFunction. Each specializes for a different primitive return type. ToDoubleFunction is ideal when fractional precision is needed, like in geometric calculations.
Source
Java ToDoubleFunction Interface Documentation
In this article, we've covered the essential usage patterns of the Java ToDoubleFunction interface. This specialized functional interface is valuable for efficient numeric processing in Java applications.
Author
List all Java tutorials.