Java Lambda

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:

parameter -> expression

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

(parameter1, parameter2) -> expression

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:

(parameter1, parameter2) -> {
  // code block
  return result;
}

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:

Example

import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {
    ArrayList<Integer> numbers = new ArrayList<Integer>();
    numbers.add(5);
    numbers.add(9);
    numbers.add(8);
    numbers.add(1);
    numbers.forEach((n) -> { System.out.println(n); });
  }
}

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.

Example

import java.util.ArrayList;
import java.util.function.Consumer;

public class Main {
  public static void main(String[] args) {
    ArrayList<Integer> numbers = new ArrayList<Integer>();
    numbers.add(5);
    numbers.add(9);
    numbers.add(8);
    numbers.add(1);

    Consumer<Integer> method = (n) -> { System.out.println(n); };
    numbers.forEach(method);
  }
}

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:

Example

interface StringFunction {
  String run(String str);
}

public class Main {
  public static void main(String[] args) {
    StringFunction exclaim = (s) -> s + "!";
    StringFunction ask = (s) -> s + "?";
    printFormatted("Hello", exclaim);
    printFormatted("Hello", ask);
  }

  public static void printFormatted(String str, StringFunction format) {
    String result = format.run(str);
    System.out.println(result);
  }
}

Anonymous Class vs. Lambda Expression

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).

Example: Same task, two ways (interface with one method):

// Functional interface (one abstract method)
interface Greeting {
  void sayHello();
}

public class Main {
  public static void main(String[] args) {
    Greeting g = new Greeting() {
      public void sayHello() {
        System.out.println("Hello from anonymous class");
      }
    };
    g.sayHello();
  }
}

// Same functional interface
interface Greeting {
  void sayHello();
}

public class Main {
  public static void main(String[] args) {
    Greeting g = () -> System.out.println("Hello from lambda");
    g.sayHello();
  }
}

Note: Rule of thumb: Use a lambda for short, single-method interfaces. Use an anonymous class when you need to override multiple methods, add fields, or extend a class.