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
-> expressionTo use more than one parameter, wrap them in parentheses:
( parameter1 , parameter2 ) -> expressionSimple 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).
Runnable example
// 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();
}
}Runnable example
// 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();
}
}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.