Java Lambda Expressions

Before lambdas, if you wanted to hand a piece of behaviour to a method, you had to write a full anonymous class, which was very wordy. A lambda expression captures just the important part: the parameters and the code to run. Think of it as a nameless method you can store in a variable or pass as an argument.

Lambda syntax

The basic shape is parameters, then an arrow ->, then the body. If the body is a single expression, its result is returned automatically and you do not need braces or the return keyword. If you need several statements, wrap them in braces and return explicitly.

// No parameters
Runnable greet = () -> System.out.println("Hello!");

// One parameter, single expression (parentheses optional)
// takes a number, returns its square
java.util.function.Function<Integer, Integer> square = n -> n * n;

// Two parameters
java.util.function.BinaryOperator<Integer> add = (a, b) -> a + b;

// Multiple statements need braces and return
java.util.function.Function<Integer, String> describe = n -> {
  if (n > 0) return "positive";
  else return "not positive";
};

A lambda only works where Java expects a functional interface, which is an interface with exactly one abstract method. The lambda becomes the implementation of that single method. Java's java.util.function package provides many ready-made ones like Function, Consumer, Predicate, and Supplier.

Lambdas with collections

The most common place beginners meet lambdas is looping over a collection with forEach, or filtering with streams. The lambda describes what to do with each element, and the collection handles the looping for you.

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

public class Main {
  public static void main(String[] args) {
    List<String> names = new ArrayList<>(List.of("Ann", "Bob", "Amy", "Sam"));

    // forEach with a Consumer lambda
    names.forEach(name -> System.out.println("Hi " + name));

    // filter with a Predicate lambda, keep names starting with A
    names.stream()
         .filter(name -> name.startsWith("A"))
         .forEach(System.out::println); // Ann, Amy
  }
}

• A lambda is a compact, nameless function written as parameters -> body.
• Lambdas only work where a functional interface (one abstract method) is expected.
• Single-expression bodies return automatically; multi-line bodies need braces and return.
• They shine with collection methods like forEach, filter, and map.