Java LongFunction Interface
Last modified: April 16, 2025
The java.util.function.LongFunction interface represents a function
that accepts a long-valued argument and produces a result. It is a functional
interface with a single abstract method apply. LongFunction is
specialized for long primitives to avoid boxing overhead.
LongFunction is part of Java's functional programming utilities added
in Java 8. It enables behavior parameterization with long primitive values. The
interface is useful when working with numeric operations that require long input.
LongFunction Interface Overview
LongFunction interface contains one abstract method. The key method
apply performs the operation on the long input value. Unlike
Function, it doesn't provide composition methods.
@FunctionalInterface
public interface LongFunction<R> {
R apply(long value);
}
The code above shows the structure of LongFunction interface. It
uses generics where R is the result type. The interface is annotated with
@FunctionalInterface to indicate its single abstract method nature.
Basic LongFunction Usage
The simplest way to use LongFunction is with lambda expressions. We define how to transform the long input to output in the apply method. The example converts long values to their string representations.
package com.zetcode;
import java.util.function.LongFunction;
public class Main {
public static void main(String[] args) {
// Define a function that takes long and returns String
LongFunction<String> toStringFunction = l -> "Value: " + l;
// Apply the function
System.out.println(toStringFunction.apply(100L));
System.out.println(toStringFunction.apply(9999999999L));
// Function using static method reference
LongFunction<String> hexFunction = Long::toHexString;
System.out.println("Hex: " + hexFunction.apply(255L));
}
}
This example demonstrates basic LongFunction usage with lambda and method reference. The toStringFunction takes long and returns String. We apply it to different long values. Method reference provides concise syntax for existing methods.
LongFunction with Mathematical Operations
LongFunction is useful for mathematical operations that take long values. We can perform calculations and return results of any type. This example calculates square roots and returns formatted strings.
package com.zetcode;
import java.util.function.LongFunction;
public class Main {
public static void main(String[] args) {
// Calculate square root and format as string
LongFunction<String> sqrtFunction = l -> {
double result = Math.sqrt(l);
return String.format("√%d = %.2f", l, result);
};
System.out.println(sqrtFunction.apply(25L));
System.out.println(sqrtFunction.apply(10000L));
System.out.println(sqrtFunction.apply(2L));
}
}
This example shows LongFunction performing mathematical operations. We calculate square roots of long values and format the results as strings. The function combines computation with string formatting.
LongFunction with Collections
LongFunction can generate collections based on long input. This example creates lists with repeated values. The size of the list is determined by the input.
package com.zetcode;
import java.util.function.LongFunction;
import java.util.Collections;
import java.util.List;
public class Main {
public static void main(String[] args) {
// Create list with n copies of "Hello"
LongFunction<List<String>> listCreator = n ->
Collections.nCopies((int) n, "Hello");
System.out.println("Size 3: " + listCreator.apply(3L));
System.out.println("Size 5: " + listCreator.apply(5L));
// Note: casting long to int may lose precision for very large values
}
}
This example demonstrates LongFunction creating collections. We generate lists containing multiple copies of a string. The size is controlled by the long input. Be cautious with large values when casting to int.
LongFunction with Streams
LongFunction works well with Java Streams for processing numeric data. This example uses it in a stream pipeline to transform long values. We convert numbers to their binary representations.
package com.zetcode;
import java.util.function.LongFunction;
import java.util.stream.LongStream;
public class Main {
public static void main(String[] args) {
// Function to convert long to binary string
LongFunction<String> toBinary = l -> Long.toBinaryString(l);
// Process stream of long values
LongStream.range(1, 6)
.mapToObj(toBinary)
.forEach(s -> System.out.println("Binary: " + s));
}
}
This example shows LongFunction in a stream pipeline. We convert a range of long values to their binary string representations. The mapToObj method accepts our LongFunction to perform the transformation.
LongFunction with Exception Handling
LongFunction implementations may need to handle exceptions. This example shows how to deal with potential exceptions when processing long values. We validate input before processing.
package com.zetcode;
import java.util.function.LongFunction;
public class Main {
public static void main(String[] args) {
// Function with input validation
LongFunction<String> safeConverter = l -> {
if (l < 0) {
return "Error: Negative value";
}
return "Processed: " + (l * 2);
};
System.out.println(safeConverter.apply(10L));
System.out.println(safeConverter.apply(-5L));
System.out.println(safeConverter.apply(0L));
}
}
This example demonstrates exception handling in LongFunction. We validate the input long value before processing. For negative numbers, we return an error message instead of processing. This prevents potential issues.
LongFunction with Custom Objects
LongFunction can return custom objects based on long input. This example creates simple Point objects from long values. The x and y coordinates are derived from the input.
package com.zetcode;
import java.util.function.LongFunction;
class Point {
private final long x;
private final long y;
public Point(long x, long y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return String.format("Point(%d, %d)", x, y);
}
}
public class Main {
public static void main(String[] args) {
// Create Point from long value
LongFunction<Point> pointCreator = l -> new Point(l, l * 2);
System.out.println(pointCreator.apply(5L));
System.out.println(pointCreator.apply(10L));
}
}
This example shows LongFunction creating custom Point objects. The function takes a long value and returns a Point with coordinates based on that value. This demonstrates how LongFunction can generate complex return types.
Combining LongFunction with Other Functional Interfaces
LongFunction can be combined with other functional interfaces for more complex operations. This example shows how to use it with Predicate for filtering. We process only even numbers.
package com.zetcode;
import java.util.function.LongFunction;
import java.util.function.LongPredicate;
public class Main {
public static void main(String[] args) {
// Predicate to check if even
LongPredicate isEven = l -> l % 2 == 0;
// Function to process even numbers
LongFunction<String> evenProcessor = l ->
isEven.test(l) ? "Even: " + l : "Odd: " + l;
System.out.println(evenProcessor.apply(4L));
System.out.println(evenProcessor.apply(7L));
}
}
This example combines LongFunction with LongPredicate. We first check if the input is even using the predicate. The function then processes the value differently based on the check. This shows functional composition.
Source
Java LongFunction Interface Documentation
In this article, we've covered the essential methods and features of the Java LongFunction interface. Understanding these concepts is crucial for functional programming with primitive long values in Java applications.
Author
List all Java tutorials.