Java Lambda Expressions (original) (raw)

Last Updated : 16 Apr, 2025

**Lambda expressions in Java, introduced in Java SE 8. It represents the instances of functional interfaces (interfaces with a single abstract method). They provide a concise way to express instances of single-method interfaces using a block of code.

Key Functionalities of Lambda Expression

Lambda Expressions implement the only abstract function and therefore implement functional interfaces. Lambda expressions are added in Java 8 and provide the following functionalities.

• **Functional Interfaces: A functional interface is an interface that contains only one abstract method.
• **Code as Data: Treat functionality as a method argument.
• **Class Independence: Create functions without defining a class.
• **Pass and Execute: Pass lambda expressions as objects and execute on demand.

**Example: **Implementing a Functional Interface with Lambda

The below Java program demonstrates how a lambda expression can be used to implement a user-defined functional interface.

Java `

// Java program to demonstrate lambda expressions // to implement a user defined functional interface.

// A sample functional interface (An interface with // single abstract method interface FuncInterface { // An abstract function void abstractFun(int x);

// A non-abstract (or default) function
default void normalFun()
{
   System.out.println("Hello");
}

}

class Test { public static void main(String args[]) { // lambda expression to implement above // functional interface. This interface // by default implements abstractFun() FuncInterface fobj = (int x)->System.out.println(2*x);

    // This calls above lambda expression and prints 10.
    fobj.abstractFun(5);
}

}

`

Structure of Lambda Expression

Below diagram demonstrates the structure of Lambda Expression:

Syntax of Lambda Expressions

Java Lambda Expression has the following syntax:

(argument list) -> { body of the expression }

**Components:

• **Argument List: Parameters for the lambda expression
• **Arrow Token (->): Separates the parameter list and the body
• **Body: Logic to be executed.

Types of Lambda Parameters

There are three Lambda Expression Parameters are mentioned below:

1. Lambda with Zero Parameter
2. Lambda with Single Parameter
3. Lambda with Multiple Parameters

**1. Lambda with Zero Parameter

**Syntax:

() -> System.out.println(“Zero parameter lambda”);

**Example: The below Java program demonstrates a Lambda expression with zero parameter.

Java `

// Java program to demonstrates Lambda expression with zero parameter @FunctionalInterface interface ZeroParameter { void display(); }

public class Geeks { public static void main(String[] args) { // Lambda expression with zero parameters ZeroParameter zeroParamLambda = () -> System.out.println( "This is a zero-parameter lambda expression!");

    // Invoke the method
    zeroParamLambda.display();
}

}

`

Output

This is a zero-parameter lambda expression!

**2. Lambda with a Single Parameter

**Syntax:

(p) -> System.out.println(“One parameter: ” + p);

It is not mandatory to use parentheses if the type of that variable can be inferred from the context.

**Example: The below Java program demonstrates the use of lambda expression in two different scenarios with an ArrayList.

• We are using lambda expression to iterate through and print all elements of an ArrayList.
• We are using lambda expression with a condition to selectively print even number of elements from an ArrayList. Java `

// Java program to demonstrate simple lambda expressions import java.util.ArrayList;

class Test {

public static void main(String args[])
{
    // Creating an ArrayList with elements
    // {1, 2, 3, 4}
    ArrayList<Integer> al = new ArrayList<Integer>();
    al.add(1);
    al.add(2);
    al.add(3);
    al.add(4);

    // Using lambda expression to print all elements of al
    System.out.println("Elements of the ArrayList: ");
    al.forEach(n -> System.out.println(n));

    // Using lambda expression to print even elements
    // of al
    System.out.println(
        "Even elements of the ArrayList: ");
    al.forEach(n -> {
        if (n % 2 == 0)
            System.out.println(n);
    });
}

}

`

Output

Elements of the ArrayList: 1 2 3 4 Even elements of the ArrayList: 2 4

**Note: In the above example, we are using lambda expression with the **foreach() method and it internally works with the consumer functional interface. The Consumer interface takes a single paramter and perform an action on it.

**3. Lambda Expression with Multiple Parameters

**Syntax:

(p1, p2) -> System.out.println(“Multiple parameters: ” + p1 + “, ” + p2);

**Example: The below Java program demonstrates the use of lambda expression to implement functional interface to perform basic arithmetic operations.

Java `

@FunctionalInterface interface Functional { int operation(int a, int b); }

public class Test {

public static void main(String[] args) {
    
    // Using lambda expressions to define the operations
    Functional add = (a, b) -> a + b;
    Functional multiply = (a, b) -> a * b;

    // Using the operations
    System.out.println(add.operation(6, 3));  
    System.out.println(multiply.operation(4, 5));  
}

}

`

**Note: Lambda expressions are just like functions and they accept parameters just like functions.

**Common Built-in Functional Interfaces

• **Comparable: int compareTo(T o);
• **Comparator: int compare(T o1, T o2);

These are commonly used in sorting and comparisons.

**Note: Other commonly used interface include **Predicate, it is used to test conditions, **Function<T, R>, it represent a function that take the argument of type T and return a result of type R and **Supplier, it represent a function that supplies results.

1. ****() -> {};**
2. ****() -> “geeksforgeeks”;**
3. ****() -> { return “geeksforgeeks”;};**
4. ****(Integer i) -> {return “geeksforgeeks” + i;}**
5. ****(String s) -> {return “geeksforgeeks”;};**

4 and 5 are invalid lambdas, the rest are valid. Details:

1. This lambda has no parameters and returns void. It’s similar to a method with an empty body: public void run() { }.
2. This lambda has no parameters and returns a String as an expression.
3. This lambda has no parameters and returns a String (using an explicit return statement, within a block).
4. return is a control-flow statement. To make this lambda valid, curly braces are required as follows: (Integer i) -> { return “geeksforgeeks” + i; }.
5. “geeks for geeks” is an expression, not a statement. To make this lambda valid, you can remove the curly braces and semicolon as follows: (String s) -> “geeks for geeks”. Or if you prefer, you can use an explicit return statement as follows: (String s) -> { return “geeks for geeks”; }.