Java 8 Series #1 - Lambda expressions

Java 8 is a revolutionary release of the Java for software development platform. It includes various upgrades to the Java programming, JVM, Tools and libraries.

Java 8 provides following features for Java Programming:

• Lambda expressions
• Method references
• Functional interfaces
• Stream API
• Default methods
• Base64 Encode Decode
• Static methods in interface
• Optional class
• Collectors class
• ForEach() method
• Parallel array sorting
• Nashorn JavaScript Engine

Although Java 8 released in March 2014, today not many java developers know the good features that this release has. Even I have not gone through these topics in detail , so I decided to make a Java 8 series of topics covering all the important features that Java 8 has.

In this post I will go in detail with Java 8's best feature - Lambda expressions

In simple words ,  lambda expressions are anonymous functions, basically methods without declared names, but which can also be passed as arguments to a method as you can with an anonymous class. 

If you’re wondering where the term lambda comes from, it originates from a system developed in academia called
lambda calculus, which is used to describe computations. 

Lets take the example of the below piece of code  which  uses anonymous inner class to associate behavior with a button click 

button.addActionListener(new ActionListener() {

    public void actionPerformed(ActionEvent event) {

        System.out.println("button clicked");

    }

});

Here we’re creating a new object that provides an implementation of the ActionListener class. This interface has a single method, actionPerformed, which is called by the button instance when a user actually clicks the on-screen button. The anonymous inner class provides the implementation of this method. So all it does is print out a message to say that the button has been clicked.

Anonymous inner classes were designed to make it easier for Java programmers to pass around code as data. Unfortunately, they don’t make it easy enough.  There are still four lines of boilerplate code required in order to call the single line of important logic.
Boilerplate isn’t the only issue, though: this code is fairly hard to read because it obscures the programmer’s intent. We don’t want to pass in an object; what we really want to do is pass in some behavior. In Java 8, we would write this code example as a lambda expression as

button.addActionListener(event -> System.out.println("button clicked"));

Instead of passing in an object that implements an interface, we’re passing in a block of code—a function without a name.  event is the name of a parameter, the same parameter as in the anonymous inner class example.  -> separates the parameter from the body of the lambda expression, which is just some code that is run when a user clicks our button.

So where exactly can you use lambdas? You can use a lambda expression in the context of a functional interface.  

I will cover more in detail about functional interface in my next post.

If you like my post then please comment, upvote , resteem and follow me @techroy