Using lambda expressions can make your Java code easier to read, stronger, and more readable.

One of the criticisms of a programming language is the number of instructions written to perform a specific processing, and sometimes you have to write a lot of code. Lambda expressions have solved this problem for a few cases and make Java stronger and easier, as C# has been the case for years.

Lambda expressions are new in Java SE 8, and these are the most notable features added to this release. Lambda expressions provide a clearer way to represent the methods and interfaces that use these expressions. Lambda expressions also improve Java object collections by making it easier to browse lists, filter and extract data from collections. Performance features strengthen Java in multi-tasking environments available on all new modern computers.

Programmers are afraid that lambda expressions will pollute the object-oriented nature of Java with the concept of functional programming. In fact, these are the same criticisms that affected the C# language a few years ago, but it has become better than before.

Lambda and LINQ expressions in C# and VisualBasic.Net

Lambda expressions were added to C# and VB.Net, primarily to support LINQ (Language-Integrated Query). Lambda expressions are anonymous functions that you can use to create tree-like expressions. In C#, you can create a lambda expression by specifying the input parameters in the Side  left of the lambda operator =>, and put the expression or block of instructions on the other side. For example, the expression x=> x*x specifies a parameter named x and returns the square of x. In VB.Net. In this case, you use anonymous functions to create lambda.

LINQ is a set of features, also introduced in Visual Studio 2008, that allowed the ability to create queries to be added. LINQ is useful for querying SQL database, XML documents, ADO.Net dataset and .Net collections, files, strings, etc.

LINQ and lambda expressions have become popular in the C# community. So, it is also possible that this will be the case for the Java.

Anonymous inner classes in Java

Anonymous inner classes in Java were the first step towards lambda expressions. You can use them by calling the inner class as shown in the following example:

JButton button = new JButton("test"); 
button.addActionListener(new ActionListener(){
 @Override public void actionPerformed(ActionEvent e){ 
 System.out.println("one click"); 
 } 
}); 

The inner class ActionListener  added to the button is an inner class that contains a method actionPerformed() in it. This saves us a bit of code, but not too much.

Interfaces that define only one method are called functional interfaces in java 8. Lambda expressions are often used with functional interfaces and internal classes.

Lambda Expression Syntax in Java

The lambda operator in Java is -> . Like C#, Java 8 attaches arguments as shown in this example:

(int x) -> x * x

We declared a variable x of integer type and we want to return the square of this variable x.

Let's consider these three lambda expressions:

(int x, int y) -> x + y 

() -> 36 

(String s) -> { System.out.println(s); } 

Now consider the example ActionListener previous with lambda:

JButton button = new JButton("test"); 
testButton.addActionListener(e -> System.out.println("one click")); 

It is clear that this code is smaller and more readable. We also notice that the inner class ActionListener became the argument e.

The java.util.function

The java.util.function was added in Java 8 and contains five types of functional interfaces:

• Predicate: A property of the passed object as a parameter.
• Consumer: An action that should be triggered with the passed object as an argument.
• Function: Renders a single result Y:   X-> Y
• Provider: Contains an instance of X
• Unary Operator: of X-> x
• Binary operator of (X, X)-> x

Object collections in Java 8