Java 8: Understanding the Lambda Expression

As we know, the Java community is continuously contributing towards improving the Java language in terms of easy development, performance, and security, among other things. The introduction of JDK 8 is another step into this process. JDK 8 introduces many exciting new features that we’ve been waiting for, including Lambda Expression, which is one of the main features introduced.

Do you continue to have problems with the anonymous class? In day-to-day development, wherever it is required to impose a certain functionality to a functional interface without creating a separate sub-class, the anonymous class is always preferred.

Despite the fact that it’s simpler and faster to implement, its syntax makes it complex to understand and adopt, therefore it decreases the readability and understandability of code. Here is an Anonymous Class Example:

Obj.addXXXListener(new XXXListener() { 
  public void XXXPerformed(XXXEvent e)
 {
    // do something.
  } 
});

Introduction of Lambda Expression

There are many functional programming languages, such as Python and Lisp, that support Lambda Expression. These languages have the capability to define a function itself as an object without needing a class/object; this is in comparison to Java, which is a pure class-based, object-oriented programming language (except primitive data types) and has everything wrapped into class or object. Other functional languages like JavaScript don’t have such limitations; instead, we can create a function as a separate entity and assign it some variable to make it further usable.

Here is an example of a function as a separate entity and its assignment:

Var printFunObj = function print(element) {
    document.write(element, '
');
}

We can use the defined variable wherever we want to make a call to print function, such as:

     [1, 2, 3, 4, 5].forEach(Print);

Prior to JDK 8, it was not possible to define an inline method and reference its definition as an object. JDK 8 has introduced the ‘Lambda Expression’ to provide the capability of defining a function as a separate entity belonging to any class. This is the first step of Java moving toward becoming a functional programming language. By using the Lambda Expression, we can write the inline function without creating its interface’s subclass and can reference it as a variable. Informally it is also known as closure. The most important features of Lambda Expression are as follows:

  • It is a way of defining an inline method without creating its interface’s subclass. In other words, unlike class-based, object-oriented languages, a method can exist without belonging to a class.
  • A method defined as Lambda Expression can be passed as a parameter to another method
  • It supports Type Interface
  • It is based on a functional interface, like the anonymous class
  • It eliminates the use of anonymous class and provides the capability to be a powerful functional programming language.

Here is an example of a Lambda Expression:

    MyFuntionalInterface funtionalInterface = (a1, a2) -> return a1 > a2;

boolean result = myComparator.myFuntion(2, 5);


Syntax of Lambda Expression

Lambda Expression has a very simple and precise syntax, and it provides the flexibility to specify the datatypes for function parameters and its return type: parameter -> expression body To understand the syntax, we can divide it into three parts:

  1. Parameters: These are function method parameters and should be matched with the signature of a function defined in a functional interface. Defining the Parameters’ datatype is optional but the number of parameters should match with the defined signatures in the interface.
  2. Expression Body: This is either a single statement or a collection of statements that represent the function definition. Defining the datatype for the return object is optional.
  3. -> : This represents the Lambda Expression operator.

Type Interface in Lambda Expression

As we know, Java is statically a type language. This is also true for JDK 8; however, since JDK 8 came about, the Java compiler has the capability of a type inference. Without introducing the new Complex type and continuing to support the existing API, the Java Compiler uses a functional interface to make a type inference for the Java language possible. A type inference is a technique where a compiler uses a method declaration signature to identify the datatype for each Lambda Expression. For each method invocation, it looks into corresponding declarations to get datatype information for each parameter, and then it returns the type and makes it applicable to properly make a method call.

Functional Interface

The functional interface is an interface with only a single abstract method. The functional interface is also known as the Single Abstract Method Interface (SAM). Prior to JDK 8, we have had to use many interfaces, like marker interface, that contain only a single abstract method. Now, JDK 8 has redefined or recreated the definition of functional interface to introduce the Lambda expression. It provides the support of the @function annotation to validate the interface as a functional interface at the compiled time. Given below is an example of an invalid functional interface, which would compile a time error.

    @FunctionalInterface
public interface SimpleFuncInterface {
  public void doWork();
  public String toString();
  public boolean equals(Object o);

Do you have experience working with the Lambda Expression in Java 8? Have questions about getting started? Let me know in the comments section below and I’ll do my best to respond ASAP.

Nitin Singhal

Nitin Singhal

Nitin Singhal is working as a Technical Lead for 3Pillar Global. He is a Sun-certified Enterprise Architect (P1), Sun-certified Business Component Developer, Sun-certified Web Component Developer, and a Sun-certified Java Developer (JDK 5). He also has over 7 years of experience in the field of Software development with various domain knowledge of Media, Retail, and ERP Services. Prior to joining 3Pillar, he worked with JK Technosoft. He holds a Masters of Computer Application from Uttar Pradesh Technical University. In his leisure time, he loves to travel, play cricket, and watch movies.

One Response to “Java 8: Understanding the Lambda Expression”
  1. akhil on

    what is the return type of lambda expression ..is it going to be the functional interface ?

    Reply
Leave a Reply

Related Posts

3 Cloud Optimization Projects That Will Pay for Themselves AWS introduced 1,430 new features and tools in 2017, including 497 in the 4th quarter alone. This means that it can be a challenge for even the mos...
How to Manage the “Need for Speed” Without Sacri... The pace of innovation today is faster than it has ever been. Customers are much more active and vocal thanks to social and mobile channels, and the c...
Determining the First Release The first thing you release needs to put the solution to your customer's most important problem in their hands. Deciding what the most important probl...
The Art of Building Rapid (and Valuable) Proofs of Concept Clients and stakeholders want results. They want assurances that their investment is well spent and they're building the right product. The software d...
Are You Doing Stuff or Creating Value? You can put a bunch of stickies on the wall, create tons of JIRA tickets, and commit lots of code, but are you creating value? Is the work your produc...