JavaLambda Expressions

Java Lambda Expressions

Lambda Expressions were added in Java 8.

Alambda 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 orif conditions. To do more complex work, use a code block with curly braces. If the lambda should return a value, use thereturn keyword:

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

Using Lambda Expressions

Lambdas are often passed as arguments to methods. For example, you can use a lambda in theforEach() method of anArrayList:

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 (afunctional interface). The lambda must match that method's parameters and return type.

Java includes many built-in functional interfaces, such asConsumer (from thejava.util package) used with lists.

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:

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 ananonymous class with alambda expression - but only if the interface is afunctional 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 interfaceinterface Greeting {  void sayHello();}public class Main {  public static void main(String[] args) {    Greeting g = () -> System.out.println("Hello from lambda");    g.sayHello();  }}