Lambdas?

A lambda is nothing but a anonymous function which accepts zero or more arguments and produces output. Lambda is basically composed with three components- argument section, an arrow and a body.

(argument ...) -> { body } // a valid pseudo code 

Example 1 :

 x -> System.out.println(x);

Example 2 :

(x,y) -> return x + y;

Example 3 :

(int x, int y) -> { int z = x + y;
return z;
}

Let me explain the examples.
First example, shows that brackets are optional if there is only a single argument.
In second example, Type of the arguments are specified. Compiler checks the type if not declared, it enable runtime typecasting for primitives. Developers can ignore the curly brackets around a single line body.
Third example shows the argument types and the body of the function.

Lambda expressions can be used to define a inline implementation of a functional interface i.e. an interface with a single method only. For example - Java developer are well familiar with the example below -

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello from thread");
    }
}).start();

new Thread(
    () -> System.out.println("Hello from thread")
).start();

In the above example, we instantiate the Runable and define the body of run method.

It is very useful in inner class declaration. For example :

button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("The button was clicked using old fashion code!");
    }
});

It can be done as below.

button.addActionListener( (e) -> {
        System.out.println("The button was clicked. From lambda expressions !");
});

Here, we don't need to create a inner class to handle the button event.

Lambda expressions are very useful while working with Collections. For example -

List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
list.forEach(n -> System.out.println(n));

@FunctionalInterface

Similar to the marker interface, there is a concept of functional interface. The interface with only a single methods are known as functional interface. @FunctionalInterface is a new interface added in Java 8 to indicate that we can simply use it in our API and take advantage of Lambda expressions. For example -

@FunctionalInterface
public interface MyFunctionalInterface {

    public void doSomeWork();

}


public class MyFunctionalInterfaceTest {

    public static void execute(MyFunctionalInterface worker) {
        worker.doSomeWork();
    }

    public static void main(String [] args) {
        execute( () -> System.out.println("Worker invoked using Lambda expression") );
    }

}

Have fun with Java 8 and Lambda expressions.

Happy coding.