What's the nearest substitute for a function pointer in Java?

Functional Interfaces and Lambdas: Let's get functional

Before Java 8, anonymous inner classes were used to encapsulate behaviours. Here's how it was done:

interface StringOperation {
    String operate(String s);
}

public static void main(String[] args) { // Where all the magic begins
    performOperation("Hello, World!", new StringOperation() {
        @Override
        public String operate(String s) { // Life is full of operations
            return s.toUpperCase(); // Yeah, it's loud here!
        }
    });
}

public static void performOperation(String s, StringOperation operation) {
    System.out.println(operation.operate(s)); // Any operation you say?
}


With Java 8 lambdas, the same job can be done much more succinctly:

performOperation("Hello, World!", s -> s.toUpperCase()); // It's shouting time!


Simplifying the Job: Standard Functional Interfaces

Why create a new interface when one already exists? Java’s standard library offers several functional interfaces for common use-cases. So, always check java.util.function before creating a new interface.

Here's an example of standard interface usage with a custom comparator:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); 
names.sort((a, b) -> a.compareTo(b)); // Who's first? Alice, Bob or Charlie?


Here, Comparator<T> is acting as a functional interface.

Light and Breezy: Method References

In scenarios where the lambda expression directly calls a method without any additional logic, we can use method references for brevity. Consider the following lambda:

Consumer<String> printer = s -> System.out.println(s); // Print it out!


Now, the method reference:

Consumer<String> printer = System.out::println; // Less typing, more printing


We use the println method directly, streamlining the code.

Advantages of Lambdas over Anonymous Classes: Top Trumps!

Lambdas have some advantages over anonymous classes:

• Conciseness and readability: Lambdas are, generally, more compact and transparent.
• Scope and closures: Lambdas can capture effectively final variables without the boilerplate.
• API Friendliness: APIs in Java expect functional interfaces, aiming for lambdas for streamlined use.

However, anonymous inner classes are still effective for complex scenarios that require a full class body.

Ensuring Harmony: Lambda's and Functional Interfaces

The correct use of lambdas depends on understanding their signatures. The parameters and return type of the lambda should match the singular abstract method of the functional interface. Here's an example with a custom functional interface:

@FunctionalInterface
interface MathOperation {
    int operate(int a, int b);
}

public static void main(String[] args) {
    MathOperation sum = (a, b) -> a + b; // Sum, sizzle, samba!
    MathOperation multiply = (a, b) -> a * b; // Multiply like rabbits

    System.out.println(calculate(5, 3, sum));       // Output: 8 – Bingo!
    System.out.println(calculate(5, 3, multiply));  // Output: 15 – Jackpot!
}

public static int calculate(int a, int b, MathOperation operation) {
    return operation.operate(a, b); // Operation in progress...
}


Let's Get Groovy: Flexibility of Functional Programming

The use of lambdas and functional interfaces allows for easy manipulation of different behaviors. Unlike traditional object-oriented programming (where several classes would be needed for polymorphic behavior), functional programming in Java allows you to pass different lambdas where the same functional interface is expected.

Putting It All Together: Practical Usage

Make use of standard interfaces

Function<Integer, Integer> square = x -> x * x; // Math hard. 

Arrays.asList(1, 2, 3, 4)
       .stream()
       .map(square)
       .collect(Collectors.toList()); // Returns [1, 4, 9, 16] – Magic!


Build an event handler

Button button = new Button("Submit");
button.setOnAction(event -> System.out.println("Button clicked!")); // Ding! Dong!


This replaces an anonymous class implementing an event listener interface.

Avoiding repetition

When the same logic repeats with slight variations, abstract the common logic and vary it with lambdas:

Executor executor = ...
Runnable commonLogic = () -> { /* Where logic lives */ };

executor.execute(commonLogic.andThen(() -> { /* Variant A */ }));
executor.execute(commonLogic.andThen(() -> { /* Variant B */ }));


Here, commonLogic encapsulates the common code, while the andThen method adds the unique code.