Java Lambda

What is a Lambda Expression?

A lambda expression is essentially a shorthand for implementing an interface with a single abstract method (Functional Interface). It eliminates the need for boilerplate code when creating instances of these interfaces.

Syntax:

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

• Parameter list: Inputs required by the lambda.
• Arrow operator (->): Separates parameters and the body.
• Body: The code to execute, which can be an expression or a block.

Why Use Lambda Expressions?

1. Conciseness: Reduces code verbosity by avoiding anonymous inner classes.
2. Functional Programming: Enables functional-style programming, making Java more flexible.
3. Improved Readability: Code becomes easier to read and maintain.
4. Streams API: Works seamlessly with Java Streams for data processing.

Components of Lambda Expressions

1. Parameters: The input variables for the lambda expression.
2. Arrow Operator (->): Links the parameters to the body.
3. Body: Contains the logic or expression to execute.

Examples of Lambda Expressions

Basic Example

// Traditional approach
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running using anonymous class.");
    }
};
runnable.run();

// Lambda expression
Runnable lambdaRunnable = () -> System.out.println("Running using Lambda.");
lambdaRunnable.run();

Output:

Running using anonymous class.
Running using Lambda.

Functional Interfaces and Lambda Expressions

A functional interface is an interface with only one abstract method. Lambda expressions can directly implement these interfaces.

Example of Functional Interface

@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}

Using Lambda with Functional Interface

public class LambdaExample {
    public static void main(String[] args) {
        // Lambda expression for addition
        Calculator addition = (a, b) -> a + b;
        System.out.println("Addition: " + addition.calculate(10, 20));

        // Lambda expression for multiplication
        Calculator multiplication = (a, b) -> a * b;
        System.out.println("Multiplication: " + multiplication.calculate(5, 4));
    }
}

Output:

Addition: 30
Multiplication: 20

Key Features of Lambda Expressions

1. No Name: Lambdas are anonymous; they do not have a name like traditional methods.
2. No Return Type: The compiler infers the return type based on the body of the lambda.
3. Simplified Syntax:
   • Single Statement: No braces are required.
   • Multiple Statements: Use curly braces { } and return keyword if necessary.

Example

// Single statement
Comparator<Integer> comparator = (a, b) -> a - b;

// Multiple statements
Comparator<Integer> detailedComparator = (a, b) -> {
    System.out.println("Comparing: " + a + " and " + b);
    return a - b;
};

Lambda Expressions in Streams

Lambda expressions are commonly used in conjunction with the Streams API to process collections.

Example: Filtering and Mapping

import java.util.Arrays;
import java.util.List;

public class StreamExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // Filtering names starting with 'A'
        names.stream()
             .filter(name -> name.startsWith("A"))
             .forEach(System.out::println);

        // Mapping names to uppercase
        names.stream()
             .map(String::toUpperCase)
             .forEach(System.out::println);
    }
}

Output:

Alice
ALICE
BOB
CHARLIE
DAVID

Common Use Cases of Lambda Expressions

Event Handling in GUIs: Simplifies event-handling code.

button.addActionListener(event -> System.out.println("Button clicked!"));

Sorting Collections:

List<String> names = Arrays.asList("Bob", "Alice", "Charlie");
names.sort((a, b) -> a.compareTo(b));
System.out.println(names);

Data Transformation with Streams: Filters, maps, and reduces collections effectively.

Custom Functional Interfaces: Use lambdas to define concise implementations of interfaces.

Limitations of Lambda Expressions

1. Limited Debugging: Lambdas can be harder to debug compared to traditional methods.
2. Complexity in Large Expressions: Overusing lambdas can lead to reduced readability.
3. Functional Interface Restriction: Lambdas only work with functional interfaces (single abstract method).