DEV Community: Sangharsha Chaulagain

Java 8 - Functional Interface

Sangharsha Chaulagain — Fri, 10 Apr 2020 14:19:26 +0000

In the previous post of this series, we discussed what is lambda expression and how can we write lambda expression. In this post, we will discuss how we can execute lambda expression. As I said, at the end of the last post, we can execute lambda expression by using Java 8's new feature, Functional Interface.

So what is Functional Interface?

The interface containing the single abstract method(SAM) are called Functional Interface. Some of the Functional Interface we may know are:

Interface	method
Runnable	run()
Callable	call()
Comparable	compareTo()
ActionListener	actionPerformed()

In version 1.8, java introduced one annotation @FunctionalInterface to specify interface as functional interface explicitly. But the annotation is optional. However, it is recommended to write the annotation. It helps prevent any additional abstract method. If the interface with annotation consists of more than one abstract method, then we get a compile-time error saying:

error: Unexpected @FunctionalInterface annotation
@FunctionalInterface
^
  CustomInterface is not a functional interface
    multiple non-overriding abstract methods found in interface CustomInterface

Note: Functional interface can have multiple default and static method.

Example 1:

@FunctionalInterface
interface A {
    void m1();
} 

@FunctionalInterface
interface B extends A {
}

@FunctionalInterface
interface C extends A {
    void m1();
}

@FunctionalInterface
interface D extends A {
    void m2();
}

In the above example, the interface D definition is invalid since it contains two methods: m1() [extended from interface A] and m2().

In the next part, I will write about how lambda expression can be used with the functional interface.

Java 8 - Lambda Expression Rule

Sangharsha Chaulagain — Thu, 19 Mar 2020 17:57:49 +0000

There are some rules to make lambda expression more concise.

Example 1:

Let's take an example:

public void displaySum(int a, int b) {
    System.out.println(a + b);
}

The valid Lambda expression of above method is:

(int a, int b) -> System.out.println(a + b);

It can be made more concise by taking out the parameter's datatypes.

(a, b) -> System.out.println(a + b);

Note: The type of the parameters can be declared explicitly, or it can be inferred from the context.

Example 2:

Let's take another example:

public int square(int a) {
    return a * a;
}

Its equivalent lambda expression is:

n->n*n;

Note:
1. If there are no curly brackets, then the return keyword is not needed.
2. If there is only one parameter in the function, then () is also not needed.

Q1. Write an lambda expression that returns length of string.

Give answer on the comment below :)

How to execute the Lambda expression?

To execute the lambda expression, we use one of the other features of java 8: Functional Interface. We will discuss it in the next post of this series.

Java 8 - Lambda Expression 101

Sangharsha Chaulagain — Thu, 19 Mar 2020 17:57:11 +0000

One of the biggest changes in Java 8 was lambda expression. The main reason to bring lambda expression to Java is to bring the benefit of functional programming into Java.

What is Lambda Expression?

It is a concise representation of anonymous functions that can be passed around. Unlike methods, it is nameless and is not associated with the particular class. It can be passed as an argument to a method or stored in a variable. Lambda expression is said to be a concise representation since there is no need to write boilerplate code as we do for anonymous classes.

Convert method into Lambda Expression

It is really very easy to convert a method into a lambda expression. Following are some rules:

Remove the name
Remove the return type
Remove the modifier
Add the arrow symbol(->)

Example 1:

Let’s take the following method,

public void sayHello() {
    System.out.println(“Hello”);
}

After removing the name, the return type and the modifier from the above method,

() {
    System.out.println(“Hello”);
}

But to make it a valid lambda expression, we need to add a special symbol,
->. Hence the above method becomes:

() -> { System.out.println(“Hello”); }

The above is the valid lambda expression. But we can concise the above lambda expression even more. If we have only one statement in the body of lambda expression, curly brackets are optional.

() -> System.out.println(“Hello”);

Note: If multiple statements are in the body of the lambda expression then the curly bracket is mandatory.