Lambda Expressions

Starting from Java 8, functional programming is supported via Lambda Expressions. A lambda expression is essentially an anonymous method (a function without a name) that can be passed as an argument to methods or stored in variables.

Functional Interfaces

A lambda expression can only be used where a Functional Interface is required. A functional interface is an interface that declares exactly one abstract method. Java marks these interfaces with the optional @FunctionalInterface annotation.

Example of a user-defined functional interface:

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

Before Java 8, you would have to define an anonymous inner class. With lambdas, the syntax is simplified to:

MathOperation addition = (a, b) -> a + b;
int result = addition.operate(5, 3); // Returns 8

Structure of Lambda Expressions

The basic syntax of a lambda is:

(parameters) -> { body }

• Without parameters: () -> System.out.println("Hello")
• Single parameter: x -> x * 2 (parentheses can be omitted)
• Multiple parameters: (x, y) -> x + y
• Multi-line body: if the body contains multiple statements, braces {} and an explicit return statement are required.

MathOperation detailedAddition = (a, b) -> {
    System.out.println("Adding...");
    return a + b;
};

Standard Functional Interfaces in Java

The java.util.function package provides several built-in functional interfaces:

• Predicate<T>: accepts an argument of type T and returns a boolean (test(T t) method).
• Consumer<T>: accepts an argument of type T and performs an operation without returning a result (accept(T t) method).
• Function<T, R>: accepts an argument T and returns a result R (apply(T t) method).
• Supplier<T>: accepts no arguments and returns a value of type T (get() method).

Try it yourself