Lambda Expression Example in Java

Introduction

Lambda expressions (Java 8+) provide a concise way to pass behaviour as data. They are widely used with collections, streams and event handlers.

Syntax

(parameters) -> expression
(parameters) -> { statements; }

Example Program

import java.util.*;

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

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

        // Comparator lambda
        List<String> names = new ArrayList<>(Arrays.asList("Charlie", "Alice", "Bob"));
        names.sort((a, b) -> a.compareToIgnoreCase(b));
        System.out.println("Sorted: " + names);

        // Custom functional interface
        MathOperation add = (x, y) -> x + y;
        MathOperation multiply = (x, y) -> x * y;
        System.out.println("Add      : " + add.operate(6, 7));
        System.out.println("Multiply : " + multiply.operate(6, 7));
    }
}

Sample Output

Running in a lambda
Sorted: [Alice, Bob, Charlie]
Add      : 13
Multiply : 42

How It Works

1. () -> ... implements the single abstract method of Runnable.
2. (a, b) -> a.compareToIgnoreCase(b) implements Comparator.compare.
3. Custom functional interfaces define the contract; the lambda supplies the implementation body.

Best Practices

• Keep lambdas short; extract complex logic into named methods.
• Prefer method references (String::compareToIgnoreCase) when they improve readability.
• Annotate custom single-method interfaces with @FunctionalInterface.

Common Mistakes

• Using lambdas where the target type is ambiguous (compiler cannot infer the functional interface).
• Modifying non-final outer variables from inside a lambda.