Java Functional Interface

| A Complete Guide to Mastering Java |

Java Functional Interface
Lambda Expression in Java

Java Functional Interface

Java functional interface is an interface that has one abstract method and it can display only one functionality.

Lambda expression in Java is used to represent a functional interface or an interface since Java 8.

Java Functional Interface Example:

class Test {

    public static void main(String[] args) {
    
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("New thread created");
            }
        
        }).start();
    }
} // we had to create anonymous inner classes before Java 8

Example 1

// use of Lambda expressions
class Test {

    public static void main(String[] args) {
    
        // lambda expression
        new Thread( () -> {
            System.out.println("New thread created");
      
        }).start();
    }
}

Example 2

@FunctionalInterface Annotation in Java

@FunctionalInterface annotation is employed to make sure that the functional interface can’t have over one abstract method. Just in case over one abstract method is present, the compiler flags an 'Unexpected @FunctionalInterface annotation' message. However, it’s not necessary to use this annotation.

@FunctionalInterface
interface Square {
    int calculate(int n);
}

class Test {

    public static void main(String[] args) {
    
        int n = 5;
        Square s = n -> n*n;
        
        int result = s.calculate(n);
        System.out.println(result);
    }
}

TRY IT YOURSELF

java.util.function Package

The java.util.function package in Java 8 contains many built-in functional interfaces in Java like:

Predicate: An abstract method test which gives a Boolean value as a result of the specified argument.

public Predicate {
    public boolean test(T t);
}

Binary operator: An abstract method that returns two values and returns the same type.

public interface BinaryOperator {
    public T apply(T x, T y);
}

Function: An abstract datatype that takes the type T and returns type R.

public interface Function {
    public R apply(T t);
}

import java.util.List;
import java.util.Arrays;
import java.util.function.Predicate;

class Test {

    public static void main(String[] args) {
        
        List< String> words = Arrays.asList("code", "coffee", "SoloLearn", "developer");
        
        Predicate< String> p = (s) -> s.startsWith("S");
        
        for (String str : words) {
            if (p.test(str))
                System.out.println(str);
        }
    }
}

TRY IT YOURSELF

Lambda Expression in Java 8

Java Lambda expressions primarily express instances of purposeful interfaces (An interface with single abstract methodology is named Java functional interface. An example is java.lang.Runnable). The Lambda expressions in Java, implement the sole abstract function and so implement functional interfaces.

Lambda expressions are a side in Java eight and supply below functionalities.

Enable to treat functionality as a method argument, or code as data.

A function that may be created while not belonging to any class.

Java lambda expression will be passed around as if it had been an object and executed on demand.

interface FuncInterface {
    void abstractFun(int n);
    
    default void normalFun() {
        System.out.println("Hello");
    }
}

class Test {

    public static void main(String[] args) {
        
        FuncInterface fobj = n -> System.out.println(5 * n);
        
        fobj.abstractFun(5);
    }
}

TRY IT YOURSELF

Java Lambda Expression Syntax

lambda operator -> body

Where lambda operator can be:

Zero Parameter

() -> System.out.println("Zero parameter lambda");

One Parameter

(p) -> System.out.println("One parameter: "+ p);

Multiple Parameters

(p1, p2) -> System.out.println("Multiple parameters: "+ p1 +", "+ p2);

import java.util.ArrayList;

class Test {

    public static void main(String[] args) {
    
        ArrayList< Integer> list = new ArrayList< Integer>();
        
        list.add(5);
        list.add(8);
        list.add(11);
        list.add(26);
        
        list.forEach(n -> System.out.println(n));
        
        System.out.println();
        
        list.forEach(n -> {
            if (n % 2 == 0)
                System.out.println(n);
        });
    }
}

TRY IT YOURSELF

A Java program to demonstrate the working of Java lambda expression with two arguments.

public class Test {

interface FuncInter1 {
    int operation(int a, int b);
}

interface FuncInter2 {
    void greeting(String message);
}

private int operate(int a, int b, FuncInter1 fobj) {
    return fobj.operation(a, b);
}

    public static void main(String[] args) {
        FuncInter1 addition = (x, y) -> x + y;
        FuncInter1 multiply = (x, y) -> x * y;
    
        Test tobj = new Test();
        
        System.out.println("Addition is: "+ tobj.operate(5, 6, addition));
        
        System.out.println("Multiplication is: "+ tobj.operate(8, 11, multiply));
        
        FuncInter2 fobj = message -> System.out.println("Hello, "+ message);
        
        fobj.greeting("SoloLearn!");
    }
}

TRY IT YOURSELF

[Examples :]

Lambda Demo
Lambda Demo #2
Float Operations
Lambda Demo #3 StringTest
Block Lambda Expressions
Use a generic functional interface

So, this was all about Java Functional Interface Tutorial. Hope you like explanation of Java Lambda Expression.

Furthermore, if you have any query regarding Java Functional Interface, feel free to ask in the comment section.

Thanks for reading!

inv

inv

HappyLearning! ;) by @boolean maybe

inv