Java Functional Programming functional interface Lambda Expression

Functional Interface(FI) refers to a special kind of interface, it's an interface with only one abstract method, that is, FI can have many other implemented methods, but only one abstract method.

package com.sosv.functional.generic;

public interface GenericInterface {

  String numberToText(String lang, Long number);

  default long countDigits(Long number) {
    return (long)(Math.log10(number) + 1);
  }
}

We can annotate with @FunctionalInterface an interface to validate that interface has only one abstract method.

@FunctionalInterface
public interface GenericInterface {

  String numberToText(String lang, Long number);
  default long countDigits(Long number) {
    return (long)(Math.log10(number) + 1);
  }

}

Before FI, if you want to create an instance of an interface, you can create a new class that implements the interface or create an anonymous class.

For example:

//Create new Class
public class GenericClass implements GenericInterface {
    @Override
    public String numberToText(String lang, Long number) {
        return "";
    }
}

var generic = new GenericClass();

//Annonymous class
var generic = new GenericInterface() {
    @Override
    public String numberToText(String lang, Long number) {
        return "";
    }
};

Lambda Expressions(LE)

Since java SE 8, In addition to FI, we have lambda expressions. For me, LE is an implementation of a FI. We can reduce the above verbose code into cleaner code, easy to read.

GenericInterface generic = (String lang, Long number) -> "";

The basic notation for a lambda expression is:

(<parameters>) -><arrow operator> <body>

parameters: It can be 0, 1, or N parameters, you can specify the type of all parameters or neither parameter. Ex: (String lang, Long number) or (lang, number)

arrow operator: It's a "-", followed by ">". Ex: ->

body: It can have {} or not. depends on the implementation of the lambda expression.

If body doesn't have {}, return keyword is implicit;

{} it's mandatory when the abstract method doesn't have a return type, that is, void.

Ex: "" or {return "";}

Kinds of FI

We have basically 4 types of FI, and all of these FI are in java.util.function package.

FI	Input	Return
Predicate	(T param)	Boolean
Function	(T param)	(R response)
Supplier	no param	(R response)
Consumer	(T param)	no response

T, R: Generic.

//Predicate
Predicate<String> hasNumber = (text) ->  text.matches(".*\\d+.*");
//Function
Function<Integer, Integer> square = (num1) -> num1 * num1;
//Supplier
Supplier<Double> random = () -> Math.random();
//Consumer
Consumer<String> logger = (text) -> System.out.println(text);

Operations of FI

//Predicate
Predicate<String> hasNumber = (text) ->  text.matches(".*\\d+.*");
Predicate<String> isLargeText = (text) ->  text.length() > 500;
hasNumber.negate() // or (text) ->  !text.matches(".*\\d+.*");
hasNumber.and(isLargeText) // or (text) -> text.matches(".*\\d+.*") && text.length() > 500
hasNumber.or(isLargeText)  // or (text) -> text.matches(".*\\d+.*") || text.length() > 500
hasNumber.test("Hello") //To get result of predicate


//Function
Function<Integer, Integer> square = (num1) -> num1 * num1;
Function<Integer, Integer> triple = (num1) -> num1 * 3;
square.andThen(triple) // or num*num*3
triple.andThen(square) // or (3*num)*(3*num)
triple.apply(2) // return 6

//Supplier
Supplier<Double> random = () -> Math.random();
random.get() // to get value

//Consumer
Consumer<String> logger = (text) -> System.out.println(text);
Consumer<String> greetings = (name) -> System.out.println("Hello " + name);
logger.andThen(greetings) // or print text and "Hello" + text
logger.accept("Hashnode") // to execute consumer

I hope you enjoy this summary of FI and LE.

Functional Interfaces in Java

Lambda Expressions(LE)

Kinds of FI

Operations of FI

Subscribe to my newsletter

Sleyter Sandoval

Sleyter Sandoval