Java Lambda Expressions

Java Lambda Expressions

Lambda expressions in Java provide a concise way to represent an anonymous function (a function without a name).
Introduced in Java 8, they simplify functional programming and reduce boilerplate code.

Often used with Functional Interfaces (interfaces with a single abstract method)
Improves readability, especially in Collections and Streams

1. Syntax

Parameters – inputs to the lambda
Arrow token -> separates parameters from the body
Expression or block – body of the lambda

2. Example: Simple Lambda Expression

interface SayHello {
void greet(String name);
}

public class LambdaExample {
public static void main(String[] args) {
// Lambda expression implementing greet method
SayHello hello = (name) -> System.out.println("Hello, " + name + "!");
hello.greet("Vipul");
}
}

interface SayHello {

void greet(String name);

}

public class LambdaExample {

public static void main(String[] args) {

// Lambda expression implementing greet method

SayHello hello = (name) -> System.out.println("Hello, " + name + "!");

hello.greet("Vipul");

}

(name) -> System.out.println("Hello, " + name + "!") is the lambda expression

3. Lambda with No Parameters

Empty parentheses () used when no parameters

4. Lambda with Multiple Parameters

interface MathOperation {
int operate(int a, int b);
}

public class MultipleParamLambda {
public static void main(String[] args) {
MathOperation add = (a, b) -> a + b;
MathOperation multiply = (a, b) -> a * b;

System.out.println("Addition: " + add.operate(5, 3));
System.out.println("Multiplication: " + multiply.operate(5, 3));
}
}

interface MathOperation {

int operate(int a, int b);

}

public class MultipleParamLambda {

public static void main(String[] args) {

MathOperation add = (a, b) -> a + b;

MathOperation multiply = (a, b) -> a * b;

System.out.println("Addition: " + add.operate(5, 3));

System.out.println("Multiplication: " + multiply.operate(5, 3));

}

Can include multiple statements using {}:

5. Lambda with Return Values

For single expressions, return keyword is optional.
For multiple statements, return is required:

6. Using Lambdas with Collections

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

public class LambdaCollectionExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("Vipul", "Anita", "Rahul");

// Print each element using lambda
names.forEach(name -> System.out.println(name));

// Sort using lambda
names.sort((a, b) -> a.compareTo(b));
System.out.println("Sorted names: " + names);
}
}

import java.util.Arrays;

import java.util.List;

public class LambdaCollectionExample {

public static void main(String[] args) {

List<String> names = Arrays.asList("Vipul", "Anita", "Rahul");

// Print each element using lambda

names.forEach(name -> System.out.println(name));

// Sort using lambda

names.sort((a, b) -> a.compareTo(b));

System.out.println("Sorted names: " + names);

}

Lambda expressions are commonly used with forEach, sort, and Streams API

7. Functional Interfaces (Predefined)

Interface	Description	Method
`Runnable`	Represents a task to run in a thread	`run()`
`Comparator<T>`	Compares two objects	`compare(T o1, T o2)`
`Consumer<T>`	Accepts an input, returns nothing	`accept(T t)`
`Supplier<T>`	Supplies a result, no input	`get()`
`Function<T,R>`	Takes input, returns result	`apply(T t)`
`Predicate<T>`	Returns boolean result	`test(T t)`

8. Example: Using `Predicate`

import java.util.function.Predicate;

public class PredicateExample {
public static void main(String[] args) {
Predicate<Integer> isEven = n -> n % 2 == 0;

System.out.println("10 is even? " + isEven.test(10));
System.out.println("7 is even? " + isEven.test(7));
}
}

import java.util.function.Predicate;

public class PredicateExample {

public static void main(String[] args) {

Predicate<Integer> isEven = n -> n % 2 == 0;

System.out.println("10 is even? " + isEven.test(10));

System.out.println("7 is even? " + isEven.test(7));

}

Simplifies code by using predefined functional interfaces

Summary

Lambda Expression = concise representation of anonymous function
Introduced in Java 8, works with functional interfaces
Reduces boilerplate for collections, threads, and event handling
Syntax: (parameters) -> expression/block

Java Lambda Expressions