|
(parameters) -> expression
|
or
|
(parameters) -> { statements; }
|
Lambda expressions reduce the need for lengthy anonymous classes. It is also used with Java’s Stream API to process collections and handle parallel tasks more effectively.
How to Create Java Lambda Function?
Creating a Java lambda function involves writing a concise expression that implements a functional interface. Lambda expressions are a way to pass behavior as a parameter, making the code more flexible and readable. So, here is a step-by-step guide on how to create and use Java lambda expressions.
Step 1: Understanding Functional Interfaces
A functional interface is an interface with a single abstract method. Java provides several built-in functional interfaces in the java.util.function packages, such as Predicate, Function, Consumer, and Supplier.
Example of a functional interface:
|
@FunctionalInterface
interface MyFunctionalInterface {
void myMethod();
}
|
Step 2: Creating a Lambda Expression
A lambda method Java provides a clear and concise way to implement the abstract method of a functional interface.
Syntax:
|
(parameters) -> expression
or
(parameters) -> { statements; }
|
Step 3: Using Java lambda expressions with Built-in Functional Interfaces
Example with Runnable:
|
Runnable r = () -> System.out.println(“Hello, world!”);
new Thread(r).start();
|
Example with ActionListener:
|
JButton button = new JButton(“Click me”);
button.addActionListener(event -> System.out.println(“Button clicked”));
|
Example with Comparator:
|
List<String> list = Arrays.asList(“apple”, “orange”, “banana”);
Collections.sort(list, (a, b) -> a.compareTo(b));
|
Step 4: Creating and Using Custom Functional Interfaces
Define a Functional Interface
|
@FunctionalInterface
interface MathOperation {
int operate(int a, int b);
}
|
Implement the Functional Interface with Java lambda expressions
|
MathOperation addition = (a, b) -> a + b;
MathOperation subtraction = (a, b) -> a – b;
MathOperation multiplication = (a, b) -> a * b;
MathOperation division = (a, b) -> a / b;
|
Use the Lambda Expression
|
public class LambdaDemo {
public static void main(String[] args) {
MathOperation addition = (a, b) -> a + b;
MathOperation subtraction = (a, b) -> a – b;
MathOperation multiplication = (a, b) -> a * b;
MathOperation division = (a, b) -> a / b;
System.out.println(“Addition: ” + operate(5, 3, addition));
System.out.println(“Subtraction: ” + operate(5, 3, subtraction));
System.out.println(“Multiplication: ” + operate(5, 3, multiplication));
System.out.println(“Division: ” + operate(6, 3, division));
}
private static int operate(int a, int b, MathOperation operation) {
return operation.operate(a, b);
}
}
|
Java Lambda Method
A lambda method in Java refers to the method implemented using a lambda expression. It’s essentially a shorthand for implementing a functional interface’s abstract method. The implementation of a functional interface method using Java lambda expressions can be passed directly to methods expecting a functional interface type.
Example:
|
List<String> names = Arrays.asList(“John”, “Jane”, “Jack”, “Doe”);
// Using lambda expression to iterate over the list
names.forEach(name -> System.out.println(name));
|
Java Lambda Types
Here, we will explore the different types of Java Lambda Expressions, their benefits, and how to use them effectively.
- No Parameter Lambda
A no-parameter lambda expression does not take any arguments. It is typically used when a task does not require any input parameters. The syntax is straightforward:
|
() -> System.out.println(“Hello, World!”);
|
In this example, the lambda expression represents a block of code that prints “Hello, World!” to the console.
- Single Parameter Lambda
A single parameter lambda expression takes one argument. It simplifies the implementation of functional interfaces with a single method that takes one parameter.
|
(x) -> System.out.println(x);
|
If the parameter type can be inferred, the parentheses can be omitted:
|
x -> System.out.println(x);
|
- Multiple Parameter Lambda
Multiple-parameter Java lambda expressions take two or more arguments. This type is useful when the functional interface method requires more than one parameter.
|
(a, b) -> System.out.println(a + b);
|
In this example, the lambda expression takes two parameters a and b, and prints their sum.
- Lambda with Return Statement
A lambda expression can also contain a return statement. This type is used when the functional interface method returns a value.
|
(a, b) -> {
return a + b;
};
|
If the lambda body contains only a single expression, the return keyword and braces can be omitted:
- Java lambda expressions with Multiple Statements
When the lambda body contains multiple statements, they must be enclosed in braces {} and the return statement (if needed) must be explicitly stated.
|
(x, y) -> {
int sum = x + y;
int difference = x – y;
return sum * difference;
};
|
- Lambda with Capturing Variables
Lambda expressions can capture variables from their enclosing scope. These variables must be effectively final (i.e., not modified after initialization).
|
int factor = 2;
(a) -> System.out.println(a * factor);
|
In this example, the lambda expression captures the factor variable from its enclosing scope.
What are the Benefits of Lambda Expression in Java?
Lambda expressions offer several benefits in Java:
- Concise Code: Lambda expressions reduce the boilerplate code required for implementing functional interfaces.
- Improved Readability: They provide a clearer and more readable way to represent a method’s intent.
- Encourages Functional Programming: Java lambda expressions facilitate a functional programming style in Java, making the code more flexible and scalable.
- Enhanced API Capabilities: Lambda expressions enhance the capabilities of Java APIs, especially the Stream API.
Java Lambda Expression Example
Let’s look at a practical example of how lambda expressions can be used in Java.
Example:
|
import java.util.*;
import java.util.stream.*;
public class LambdaExample {
public static void main(String[] args) {
List<String> names = Arrays.asList(“Anna”, “Bob”, “Charlie”, “David”);
// Using lambda expression to filter and print names
List<String> filteredNames = names.stream()
.filter(name -> name.startsWith(“A”))
.collect(Collectors.toList());
filteredNames.forEach(name -> System.out.println(name));
}
}
|
In conclusion, Java Lambda Expressions, introduced in Java 8, make writing Java code easier and more efficient. They allow you to write shorter clearer code by passing methods around like variables. This simplifies implementing interfaces with one method. Lambda expressions are beneficial with Java’s Stream API for processing collections. They come in types like no single and multiple parameters. Using them makes your code more readable and flexible. Embracing lambda expressions helps create more maintainable and scalable Java applications, making them essential for any Java developer.
Advanced Certification in Applied Data Science, Machine Learning & IoT By E&ICT Academy, IIT Guwahati
9 months
Certification in Data Science and Machine Learning With Python By The
IoT Academy Noida
180 Hrs
