What Is a Lambda Expression?

Lambda expressions, introduced in Java 8, provide a concise way to define anonymous functions—functions without names. At its core, a lambda is simply an anonymous function that can be passed around like any other object. Lambdas enable you to define small pieces of functionality and pass them wherever a functional interface is required. A functional interface contains exactly one abstract method, such as Runnable with its single run() method used extensively in multithreading.

Lambda Expression Syntax

(parameterList) -> { functionBody }

The syntax breaks down into three components:

1. Parameter list - Comma-separated parameters. Parentheses are optional when there's only one parameter. Empty parameter lists still require parentheses. Parameter types can be omitted as the JVM can infer them.
2. Arrow operator (->) - Separates parameters from the function body.
3. Function body - Either a single expression or a statement block. When using a single expression, you can omit braces and the return keyword since the expression's result becomes the lambda's return value. Multiple statements or explicit returns require braces.

Example 1: No Parameters

() -> System.out.println("Welcome!")

Example 2: Single Parameter

message -> System.out.println("Message: " + message)

Example 3: Two Parameters

(a, b) -> a + b

Example 4: Return Value Considerations

When a lambda contains conditional logic with return values, every branch must produce a value. The folowing code fails compilation because the else branch lacks a return statement:

// This will not compile
(speed, limit) -> {
    if (speed > limit) {
        return true;
    }
    // Missing return for else branch
}

Example 5: Variable Scope

Lambda expressions can acces variables from their enclosing scope:

String prefix = "User: ";
Consumer<String> printer = name -> System.out.println(prefix + name);

Method References and Constructor References

Method and constructor references exist to simplify lambdas further. If your lambda body merely delegates to an existing method, you can reference that method directly instead of writing redundant code. Think of the reference as borrowing existing implementation.

Method References

Method references come in three forms:

1. instance::instanceMethod (instance method of an object)
2. Class::instanceMethod (instance method of a class)
3. Class::staticMethod (static method)

For form one, all parameters passed to the functional interface's abstract method flow to the referenced instance method. Consider System.out::println—it replaces text -> System.out.println(text). The reference's parameter count must match the abstract method's parameter count.

For form two, the first parameter becomes the method's target object, while remaining parameters become the actual method arguments. Given a Employee class:

public class Employee {
    private String name;
    private int yearsEmployed;

    public int compareExperience(Employee other) {
        return Integer.compare(this.yearsEmployed, other.yearsEmployed);
    }
}

Sorting employees by experience:

List<Employee> staff = new ArrayList<>();
// ... populate list
staff.sort((e1, e2) -> e1.compareExperience(e2));

This simplifies to:

staff.sort(Employee::compareExperience);

Here, the first parameter to compare() (the Employee to compare against) becomes the method's target object.

For form three, all parameters pass directly to the static method. Math::max is equivalent to (a, b) -> Math.max(a, b).

Important: Method references only work when the lambda's functionality exactly matches the referenced method—both parameters and return type must align.

To interpret any method reference, first identify its type (1, 2, or 3), then reconstruct the corresponding lambda expression to understand its behavior.

Constructor References

Constructor references resemble method references but reference constructors. Syntax: ClassName::new.

When a class has multiple constructors, the compiler determines which one to invoke based on the functional interface's abstract method signature. For a Product class:

public class Product {
    private String code;
    private double price;

    public Product() {
        this.code = "UNKNOWN";
        this.price = 0.0;
    }

    public Product(String code, double price) {
        this.code = code;
        this.price = price;
    }
}

The constructor called depends entirely on the parameters expected by the target functional interface.

Practical Lambda Expression Use Cases

Java 8's standard library extensively uses functional interfaces (Runnable, Comparator, Function, Consumer, Predicate), making lambdas highly useful in everyday coding.

Filtering List Elements

The filter method accepts a Predicate<T> functional interface. To extract strings starting with 'J':

List<String> names = Arrays.asList("John", "James", "Alice", "Bob");
List<String> filtered = names.stream()
    .filter(name -> name.startsWith("J"))
    .collect(Collectors.toList());

Sorting Lists of Custom Objects

Given an Employee class with an age field:

public class Employee {
    private String name;
    private int age;

    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

Sorting by age becomes straightforward:

List<Employee> team = new ArrayList<>();
// ... add employees
team.sort((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()));

Why Lambda Expressions Exist

Understanding the motivation requires examining inner classes first.

Static Inner Classes

Static inner classes use the static keyword. They can only access static members of the outer class and can be instantiated without requiring an outer class instance:

public class Outer {
    static class Inner {
        void display() {
            System.out.println("Static inner class");
        }
    }
}

Outer.Inner instance = new Outer.Inner();

Instance Inner Classes

Instance inner classes are the most common form. They can access all members of the outer class, including private ones. Instantiation requires an outer class instance first:

Outer outer = new Outer();
Outer.InstanceInner inner = outer.new InstanceInner();

Local Inner Classes

Local inner classes are defined within methods or blocks. They can access all local variables in their enclosing scope, including effectively final ones:

public void process() {
    int count = 5;
    class LocalProcessor {
        void execute() {
            System.out.println("Count: " + count);
        }
    }
}

Anonymous Inner Classes

Anonymous inner classes lack a name and serve for one-time object creation, typically implementing interfaces or extending abstract classes. While they can implement multiple abstract methods from regular interfaces, lambdas are restricted to single-abstract-method functional interfaces. Despite this limitation, lambdas produce significantly more concise code than equivalent anonymous inner class implementations.

Syntax Reference

(parameterList) -> expression
(parameterList) -> { statementList }

Syntax Element	Description
parameterList	Zero or more comma-separated parameters
->	Arrow delimiter separating parameters from body
expression	Single expression returning a value
{ statementList }	Multiple statements requiring explicit returns