Understand the idea

A lambda supplies an implementation for a functional interface: an interface with one abstract method. It is useful for short callbacks and transformations. A captured local variable must be final or effectively final; keep side effects deliberate.

Explore the details

Java Lambda Expressions

Lambda Expressions were added in Java 8.

A lambda expression is a short block of code that takes in parameters and returns a value. Lambdas look similar to methods, but they do not need a name, and they can be written right inside a method body.

Syntax

The simplest lambda expression contains a single parameter and an expression:

To use more than one parameter, wrap them in parentheses:

Simple expressions must return a value immediately. They cannot contain multiple statements, such as loops or if conditions. To do more complex work, use a code block with curly braces. If the lambda should return a value, use the return keyword:

Using Lambda Expressions

Lambdas are often passed as arguments to methods. For example, you can use a lambda in the forEach() method of an ArrayList:

Lambdas in Variables

A lambda expression can be stored in a variable. The variable's type must be an interface with exactly one method (a functional interface). The lambda must match that method's parameters and return type.

Java includes many built-in functional interfaces, such as Consumer (from the java.util package) used with lists.

Lambdas as Method Parameters

You can also pass a lambda expression to a method. The method's parameter must be a functional interface. Calling the interface's method will then run the lambda expression:

Anonymous Class vs. Lambda Expression

Lambdas with the Stream API

Lambdas shine brightest with the Stream API — a powerful way to process collections with a pipeline of operations: filter, transform, and collect in one readable chain.

import java.util.List;
import java.util.stream.Collectors;

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// Pipeline: filter evens → square them → collect to list
List<Integer> evenSquares = numbers.stream()
    .filter(n -> n % 2 == 0)         // keep even numbers
    .map(n -> n * n)                  // square each
    .collect(Collectors.toList());
System.out.println(evenSquares);  // [4, 16, 36, 64, 100]

// Sum all numbers
int total = numbers.stream()
    .reduce(0, Integer::sum);
System.out.println("Sum: " + total);  // Sum: 55

// Find any number greater than 7
numbers.stream()
    .filter(n -> n > 7)
    .findFirst()
    .ifPresent(n -> System.out.println("Found: " + n));  // Found: 8

Method References

When a lambda just calls an existing method, you can replace it with a method reference using :: — more concise and easier to read.

In Java 8+, you can often replace an anonymous class with a lambda expression – but only if the interface is a functional interface (one abstract method).

A complete runnable example

This complete Main.java program focuses on the lesson idea. Reference fragments above may demonstrate individual statements; this example includes the imports, entry point, and supporting types it needs.

import java.util.*;
public class Main {
    public static void main(String[] args) throws Exception {
        List<Integer> values = Arrays.asList(1, 2, 3);
        values.forEach(n -> System.out.println(n * 2));
    }
}

2
4
6

Change it. Run it. Understand it.

Load this lesson example into the editor. Change one value or statement, predict the result, then press RUN to execute Java.

Make it your own

Your learning checkpoint

• Explain the example without reading the output first.
• Make the change requested in the practice task.
• Describe why the result changed—or why compilation failed.

Ready to move on? Follow the next lesson in course order, or return to the curriculum to review a prerequisite.