Through below code, I would like to explain Lambda expressions a new feature of java 8 and how it can be used efficiently to reduce the code.
Lambda expressions provides a concise
way to express instances of single-method interfaces (functional interfaces).
A functional interface is an
interface with exactly one abstract method, and it may contain multiple default
or static methods.
Lambda expressions facilitate a more
functional programming style in Java, allowing developers to pass behavior
(code) as an argument to methods or to express instances of functional
interfaces in a more compact form. The syntax of a lambda expression is concise
and focused on expressing the behavior rather than the structure of the code.
Here's a brief overview of lambda
expressions and their syntax:
(parameters) -> expression
or
(parameters) -> { statements; }
Parameters: A comma-separated list of parameters enclosed in
parentheses. If there are no parameters, empty parentheses are used. For
example:
· (int a, int b) -> a + b
· () -> "Hello, World!"
Arrow (->): The arrow token, which separates the parameters from the
body of the lambda expression.
Body: The body of the lambda expression, which can be a single
expression or a block of statements. If the body is a single expression, you
can omit the curly braces and the return keyword. If the body is a block of
statements, you must use curly braces {} and include the return statement if
needed.
Below is the sample example for the Lamda expressions
package com.examples;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collector;
import java.util.stream.Collectors;
public class LambdaExpressionsExample {
public static void main(String[] args) {
List<Integer> numbersList= Arrays.asList(1,2,3,4,5);
System.out.println("Initial Numbers");
numbersList.stream().forEach(n->System.out.print(n+" "));
System.out.println("\nSquare of the Numbers");
squareOfTheNumbers(numbersList).stream().forEach(n->System.out.print(n+" "));
System.out.println("\nSquare of even Numbers");
squareOfTheEvenNumbers(numbersList).stream().forEach(n->System.out.print(n+" "));
}
public static List<Integer> squareOfTheNumbers(List<Integer> numberList)
{
/*
* @ numberList: list containing integers (List<Integer>.
*
* @ .stream(): This method is called on numberList to convert it into a stream.
* Streams in Java provide a sequence of elements on which you can perform various operations.
*
* @ .map(n -> n*n): The map operation transforms each element of the stream using the provided function.
* In below case, it squares each element (n * n). The result is a new stream with the squared values.
*
* @ collect(Collectors.toList()): Finally, the collect operation is used to gather the elements of the stream into a new list.
* Collectors.toList() is a collector that collects the elements into a List.
*
*/
List<Integer> result =numberList.stream().map(n -> n*n).collect(Collectors.toList());
return result;
}
public static List<Integer> squareOfTheEvenNumbers(List<Integer> numberList)
{
/*
* @ .filter(n -> n%2 == 0): The filter operation is used to retain only those elements that satisfy a given condition.
* In this case, it keeps only the even numbers (where n % 2 == 0).
*
*/
numberList = numberList.stream().filter(n -> n%2==0).map(n-> n*n).collect(Collectors.toList());
return numberList;
}
}
