How to pass a function as a parameter in Java?

java

lambda

functional-programming

higher-order-functions

byAlex Kataev·Oct 28, 2024

Java's lambda expressions and Functional Interfaces such as Function<T,R>, Consumer<T>, Supplier<T>, and Predicate<T> allow you to pass a function as a method parameter.

Here's a quick demonstration with Function<Integer, Integer> for calculating a square.

// Method using the magical powers of Lambdas to turn an integer into... another integer!
public static void applyFunction(Integer value, Function<Integer, Integer> function) {
    System.out.println(function.apply(value));
}

// In the wild world of Lambdas, even 5 can magically turn into 25.
applyFunction(5, x -> x * x); // Outputs 25

In this example, the applyFunction method takes any Integer-to-Integer function, and here we have conjured a lambda to calculate the square.

Function passing in Java: Traversing the ages

Function passing in Java has evolved and adapted with Java versions, each with its own characteristics:

Pre-Java 8: Era of Anonymous classes

applyFunction(5, new Function<Integer, Integer>() {
    public Integer apply(Integer x) {
        return x * x; // Because why count squares on graph paper when you can make Java do it?
    }
});

Though anonymous inner classes did the job, it was like using a sledgehammer to crack a nut: overkill for simple functions!

Java 8 and beyond: Resurgence with Lambda and Method references

Here, Java said, "Why write four lines, when one will do?"

With Lambda expressions:

applyFunction(5, x -> x * x); // Java's gift to the lazy programmers

And Method references:

class Utils {
    static Integer square(Integer x) {
        return x * x; // Who knew x*x could have its own method?
    }
}
applyFunction(5, Utils::square); // A wild Method Reference appears!

Method references offer a more readable way to reference existing methods.

Design your Functional interface

If built-in functional interfaces just don't cut it, bring out your designer hat and create your custom functional interface:

@FunctionalInterface
interface Transformer {
    Integer transform(Integer x); // Autobots, roll out.
}

public static void main(String args[]) {
    Transformer square = x -> x * x;
    applyFunction(5, square::transform); // Another Transformers sequel!
}

Command Pattern: The big guns

For those tough nuts that simple function passing can't crack, Command Pattern enters the game!:

interface Command {
    void execute(); // Not Execute Order 66, though.
}

public static void runCommand(Command command) {
    command.execute();
}

// Finally, a lambda we can order around
runCommand(() -> System.out.println("I'm a Lambda. I serve."));

Ideal for complex operations like queues, undo operations, and more.

Unleashing the Power of Lambdas:

Rejoice, for Lambdas and Functional interfaces can handle even those out-of-textbook scenarios!

Higher-order functions and closures

Higher-order functions for the win! Even closures are all in a day's work for Lambdas:

Function<Function<Integer, Integer>, Integer> higherOrderFunction = (func) -> func.apply(5);
int result = higherOrderFunction.apply(x -> x * x); // Because who doesn't love functions within functions?

Functional Interfaces: More than meets the eye

Other functional interfaces like Supplier<T>, Predicate<T> give more power to your arsenal:

// Hands up if you remember this from your Math classes
List<Integer> values = Arrays.asList(1, 2, 3);
boolean allPositive = values.stream().allMatch(x -> x > 0); 

// "Wait until I ask for you", says the Supplier.
Supplier<Integer> lazyValue = () -> computeExpensiveValue();

Reflection: Use with caution

While tempting to use reflection for functional programming, beware! You're entering a world of complexity and potential performance issues.

Guava to the rescue

Compatibility issues with Java versions? Worry not, for Guava comes to your aid with their own set of functional interfaces.

com.google.common.base.Function<Integer, Integer> guavaFunction = x -> x * x; // Guava: "Java8, Hold my beer."

Advanced concepts in Functional Programming

Java offers a world of possibilities when it comes to functional programming:

Beyond One Abstract Method

Functional interfaces, though single-method, can also include static and default methods, lending a helping hand without disturbing the lambda-compatibility.