Lambda Expressions

A lambda expression is a compact way to represent an anonymous function — a block of code with parameters that can be passed around like a value. Java 8 introduced lambdas primarily to reduce the boilerplate of anonymous inner classes when implementing interfaces that have exactly one method, such as event listeners, comparators, and runnables.

Instead of writing a full class definition just to supply one piece of behavior, a lambda lets you write only the parameters and the logic: (parameters) -> expression or (parameters) -> { statements; }. The compiler infers the target type from the context, most often a functional interface.

Why it matters

Lambdas changed how Java is written. Streams, comparators, event handlers, thread tasks and most of the Spring API expect you to pass behaviour as a short function. Code written since Java 8 is hard to read, and harder to write, without being comfortable with the -> syntax.

Lambda Syntax Forms

Java accepts several equivalent shapes depending on how much you want to write explicitly. All of the following are valid ways to express "take two ints and return their sum":

• (int a, int b) -> a + b — explicit parameter types, single expression.
• (a, b) -> a + b — inferred parameter types (the compiler figures out int from context).
• (a, b) -> { return a + b; } — block body with an explicit return statement.
• x -> x * x — parentheses can be dropped for exactly one inferred-type parameter.

Replacing Anonymous Inner Classes

Before Java 8, passing behavior meant writing an anonymous inner class that implemented an interface. A lambda produces the same effect with far less ceremony, because the compiler already knows which single method is being implemented from the target functional interface — you only supply the parameter list and body, not the interface name or method signature again.

Variable Capture: Effectively Final

A lambda can read local variables from its enclosing scope, but only if those variables are "effectively final" — meaning they are never reassigned after initialization, even if not explicitly marked final. This restriction exists because the lambda may outlive the method call (for example, if stored and invoked later), so Java captures the variable's value rather than allowing it to change underneath the lambda.

Example

import java.util.Arrays;
import java.util.List;

public class LambdaDemo {
    public static void main(String[] args) {
        Runnable task = () -> System.out.println("Running via lambda");
        task.run();

        List<String> names = Arrays.asList("Banana", "apple", "Cherry");
        names.sort((a, b) -> a.compareToIgnoreCase(b));
        System.out.println(names);

        int factor = 3; // effectively final, safe to capture
        Runnable multiplier = () -> System.out.println("Factor is " + factor);
        multiplier.run();
    }
}

Running via lambda
[apple, Banana, Cherry]
Factor is 3

Exercise

Sort the words by length, shortest first, by passing a lambda to sort.

Expected output: [fig, kiwi, mango]

import java.util.ArrayList;
import java.util.List;

public class SortByLength {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>(List.of("mango", "fig", "kiwi"));

        // TODO: sort the list by word length using a lambda

        System.out.println(words);
    }
}

import java.util.ArrayList;
import java.util.List;

public class SortByLength {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>(List.of("mango", "fig", "kiwi"));

        words.sort((a, b) -> Integer.compare(a.length(), b.length()));

        System.out.println(words); // [fig, kiwi, mango]
    }
}

Quick quiz

Interview questions