Are You…,

Tired of writing endless lines of code for simple tasks?

Then Let Us…,

Discover how Lambda expressions can transform your Java coding experience.

Introduction

The Lambda expression is an important new feature of Java SE 8. Its main objective is to bring the benefits of functional programming into Java. Lambda expressions are used to implement functional interfaces with only one abstract method. Java provides an annotation @FunctionalInterface, which is used to declare an interface as a functional interface.

Java Lambda expressions are considered functions, so the compiler does not generate .class files and saves a lot of code. It helps to iterate, filter, and extract data from the collection. 

What Are Lambda Expressions?

A Lambda expression is an anonymous function — a block of code that can be passed around, executed later, or treated like data. Lambda expressions are primarily used to define the implementation of a functional interface in a concise way.

Lambda Expression is also known as anonymous functions or closures.

The above graphic portrays the following:

• A Lambda expression can have zero or more number of parameters/arguments (Ex: 1 & Ex:2).

• If multiple parameters are present, then these parameters should be separated with a comma (Ex:2).

• Usually, we can specify the type of parameter. If the compiler expects the type based on the context, then we can remove type Ex:3 & Example 2 can be written as:

         (a+b) -> System.out.println (a+b);

• If a zero number of parameters is available, then we must use an empty parameter [ like ()] Ex:1.

• Like the method body, Lambda expression body also can contain multiple statements. If more than one statement is present, then we must enclose it within curly braces. If one statement is present, then curly braces are optional (Ex: 3).

• Once we write a Lambda expression, we can call that expression just like a method, for this functional interface is required.

Functional Interface

If an interface contains only one abstract method or Single Abstract Method (SAM), such type of interface is called a functional interface, and we can write any number of default and static methods inside it.

Example:

1. Runnable: It contains only the run() method.
2. Comparable: It contains only the compareTo () method.
3. ActionListener: It contains only the actionPerformed () method.
4. Callable: It contains only the call () method.

In Java 8, Sun Micro System introduced @Functional Interface annotation to specify the interface as a Functional Interface. Inside the Functional Interface, we can take only one abstract method (Ex.5). If we take more than one abstract method, then the compiler raises an error message (Ex.6).

Functional Interface for Concerning Inheritance

If an interface extends to the Functional Interface, and if the child interface does not contain an abstract method, then the child interface is also a Functional Interface (Ex.7).

We can define the same parent interface abstract method in the child interface.

In the child interface, we cannot define any new abstract methods. Otherwise, the child interface will not be Functional Interface. If we try to use the @Functional Interface annotation, then the compiler will give an error message (Ex.9).

Functional Interface and Lambda Expressions

A Functional Interface is required once Lambda expressions are written to leverage its functionality. Using Lambda Expressions, we can apply the functional interface concept there. Functional Interfaces can be used to refer to a Lambda Expression. We can use Lambda Expressions where the Functional Interface concept applies.

In the above example, we have seen a user-defined interface and now will try to implement one pre-defined interface.

Anonymous Inner Classes vs. Lambda Expressions

Wherever anonymous inner classes are used, there is often an opportunity to replace them with Lambda expressions to reduce code length and simplify complexity. While an anonymous inner class can extend a concrete or abstract class, or even implement an interface with multiple methods, a Lambda expression can only be used to implement a functional interface—an interface with a single abstract method.

An anonymous inner class can be replaced with a Lambda expression only if it implements a functional interface. Therefore, not every instance of an anonymous inner class can be replaced with a Lambda expression.

Anonymous inner class! = Lambda Expression

Differences Between Anonymous Inner Classes and Lambda Expression

Anonymous Inner Classes	Lambda Expression
A class without a name	A method without a name (anonymous function)
Can extend abstract and concrete classes	Cannot extend abstract and concrete classes
Can implement an interface that has multiple abstract methods	Can implement an interface that has a single abstract method, also known as a functional interface
Inside the anonymous inner class, we can declare instance variables	Inside a Lambda expression, instance variables cannot be declared; any variables declared within it are treated as local variables.
Can be Instantiated	Cannot be instantiated
Best choice for overseeing multiple methods	Best choice for handling interfaces with a single abstract method, also known as functional interfaces
Memory is allocated on demand whenever we are creating an object	Resides in the permanent memory of JVM (Method Area)

Conclusion

Lambda expressions have brought a significant improvement to the Java language, promoting a more functional approach to programming, and reducing the verbosity of anonymous inner classes. By enabling more concise and readable code, they have revolutionized how Java developers write everyday tasks, especially when working with collections and functional-style programming.

The use of Lambda expressions, combined with functional interfaces and the Streams API, has made Java much more flexible and powerful, opening the door to writing more declarative and expressive code.

If you have not yet explored Lambda expressions, now is a great time to start, as they are widely used in modern Java development. Happy coding!