This feature is introduced in Java 8. This feature is concise lines of code and enables functional programming.
Lambda Expression:
- It is an anonymous function
- Without return type
- Without modifiers
- With special symbol “->” arrow
Example:
public void m(){
System.out.println("Hello");
}
() -> System.out.println("Hello");If the lambda expression method body contains one line then curly “{}” braces are optional and contains multiple lines then curly braces are mandatory.
() -> System.out.println("Hello");Example:
public void m(int a,int b){
System.out.println(a*b);
}
(int a,int b) -> System.out.println(a*b);Sometimes the compiler can guess the type of parameter automatically. In that case, we don’t need to specify the type of parameter explicitly.
(a,b) -> System.out.println(a*b);Example:
public int square(int n) {
return n * n;
}
(n) -> {
return n * n;
}Without curly “{}” braces we don’t need to specify “return” explicitly. But with curly “{}” braces “return” is mandatory.
(n) -> n*n;If the input parameter is single then the parenthesis “()” is optional.
n -> n*n;Note: Lambda Expression is used to provide an implementation of an interface which is a Functional Interface. Lambda Expression will not generate a “.class ” file due to this performance increase.
Example:
interface Square {
void square(int x);
}
//Implementation class of interface
class SquareImpl implements Square {
@Override
public void square(int x) {
System.out.println("Square Of No. is:" + x * x);
}
}
public class Test {
public static void main(String[] args) {
Square sq = new SquareImpl();
sq.square(10);
}
}Output:
Square Of No. is:100- In the above example without Lambda Expression, we can implement an Interface through the extra class implementation of an Interface.
- In the above example, the “Square” interface has a single abstract method. So, the “Square” interface is a Functional Interface.
- In this example it also generates an extra “.class” file i.e., SquareImpl.class.
Example:
interface Square {
void square(int x);
}
public class Test {
public static void main(String[] args) {
//Anonymous Inner class
Square sq = new Square() {
@Override
public void square(int x) {
System.out.println("Square Of No. is:" + x * x);
}
};
sq.square(10);
}
}Output:
Square Of No. is:100- In the above example, we can implement an interface with an anonymous inner class.
- In the above example it also generates an extra “.class” file.
- In the above example length of code is decreased as compared to the extra implementation of an interface.
Example:
interface Square {
void square(int x);
}
public class Test {
public static void main(String[] args) {
//Lambda Expression
Square sq = (x) -> System.out.println("Square Of No. is:" + x * x);
sq.square(10);
}
}Output:
- In the above example, we can implement that interface through Lambda Expression because the “Square” interface is a Functional Interface. Here we can concise the code through this Java 8 feature.
- Lambda Expression is enabling functional programming in the code.
- Lambda Expression helps without generating an extra class to implement the functional interface.
- Lambda Expression helps without generating an anonymous inner class to implement the functional interface.
- In the above example not generating an extra “.class” file.
- In the above example length of code decreases as compared to the extra implementation class and an anonymous inner class of functional interface.
Conclusion:
This topic is explained What is Lambda Expression? How can we write Lambda Expression? How to identify Lambda Expression? How to use Lambda Expression?