Lambda expressions provide the simplest and shortest way to define anonymous functions. Java Swing frequently uses anonymous functions for event handling. Lambda expressions define the body of Functional Interfaces. An interface that has only one abstract method is called a Functional Interface. It can be annotated by @FunctionalInterface annotation.

Let's define HelloInt functional interface that has an abstract method say():

@FunctionalInterface
interface HelloInt {
    public void say();
}
          

Now, let's define an interface using the old anonymous function approach:

HelloInt aFun = new HelloInt() {
    public void say() {
        System.out.println("Hello Anonymous Function");
    }
};
aFun.say();
          

Let's define the anonymous function using a Lambda expression:

HelloInt lambFun = () -> System.out.println("Hello Lambda");
lambFun.say();
          

The above example clearly shows the shortest code of an anonymous function definition. The only condition is that the interface must have a single abstract method. In other words, the interface must be a Functional Interface.

Some of the most frequently used functional interfaces are java.lang.Runnable and java.lang.Comparable.

Lambda Expression Syntax:

A lambda expression is composed of three parts:

Lambda expressions may have zero or more arguments. The body can be either a single expression or a statement block.

Let's define MathInt functional interface with multiple parameters. It will have multiple lambda definitions to calculate addition, subtraction, and multiplication of two numbers:

@FunctionalInterface
interface MathInt {
    public int calculate(int a, int b);
}

MathInt add = (a, b) -> {
    return a + b;
};
MathInt multiply = (a, b) -> {
    return a * b;
};
MathInt subtract = (a, b) -> {
    return a - b;
};

int a = 10;
int b = 5;
System.out.println("Add " + add.calculate(a, b));
System.out.println("Multiply " + multiply.calculate(a, b));
System.out.println("Subtract " + subtract.calculate(a, b));
          

Method Reference as Lambda

Java lambda implementation provides a shorter way to express a method call using the :: operator, which separates the method name from the name of an object or class in a method reference.

Here is an example of a method reference:

@FunctionalInterface
interface GreetingInt {
    public void hello(String name);
}

GreetingInt g = System.out::println;
g.hello("Ram");
g.hello("Shyam");
          

The above example passes a reference to the println() method using the double colon :: operator. It tells the Java compiler that the method will be applied to the passed parameter of the lambda method.

GreetingInt g = System.out::println; is the replacement for GreetingInt g = (n) -> System.out.println(n);

You can reference the following types of methods:

• Static method
• Instance method on parameter objects
• Instance method
• Constructor

Example Source Code:

Click here P16lambda Expressions