Functional Interface in-depth

f(x) -> y 

In the functional programming paradigm, computation is expressed in terms of mathematical functions that avoid mutable state and side effects. The result of a function is solely determined by its inputs. Invoking a functional multiple times with the same inputs will always return the same result.

@FunctionalInterface
public interface MyInterface {
    boolean isMyMethod();
}

In Java 8, all methods added in the interface are always public, so there is no need to add an access modifier (usually the IDE you are coding will suggest removing this modifier). The same situation is for abstract keyword. I indicated that it is about version 8, because as of Java 9 private methods are also allowed in interfaces.

The above interface is functional because has declared only one abstract method. As you can see, I’ve added annotation @FunctionalInterface which is not required. But generally, in my opinion it is worth adding that annotation in the code because it triggers a compile-time check that the interface does, in fact, satisfy the requirement. Thus if the interface has either zero abstract methods or more than one, you will get a compiler error.

Moreover, functional interfaces can also have default and static methods. Both of them have implementations, so the compiler doesn’t treat them as abstract methods – that’s why everything works! The following code snippet shows such an example:

@FunctionalInterface
public interface MyInterface {

    boolean isMyMethod();
    
    static int addOneToNumber(int number) {
        return number + 1;
    }
    
    default void executeAnotherMethod() {
        System.out.println("Executing method...");
    }
}

I’d like to note that if we add a second (abstract by default) method to an interface, a compile-time error will be thrown because the annotation clearly marks this interface as functional.

What about interface inheritance? Generally, inheritance is an import pillar of Object Oriented Programming, because this mechanism allows members of one class to inherit from another. In the case of functional interfaces, the annotation @FunctionalInterfaces checks the current interface. So if one interface extends an existing functional interface and adds another abstract method, it is not itself a functional interface. Without the @FunctionalInterface annotation, this compiles, because it’s a standard interface. It cannot, however, be the target of a lambda expression.

Everything clear so far? Now, I am going to disrupt our ideology a bit. In theory, a functional interface can only have one abstract method, but there is one edge case. You can declare methods in Object as abstract in an interface, but that doesn’t make them abstract. Usually the reason for doing so is to add documentation that explains the contract of the interface. An example of such an exception can be the Comparator interface. It is a functional interface, even though it has not only the compareTo abstract method declaration, but also the equals method declaration. The rules for functional interfaces say that methods from Object don’t count against the single abstract method limit. For example, this is a valid functional interface:

@FunctionalInterface
public interface MyInterface {
  int myFunction(int firstNumber, int secondNumber);
  
  default int getValue(){
    return 0;
  }

  public String toString();
  public boolean equals(Object o);
}

While many interfaces in the Java standard library contain only a single, abstract method and are thus functional interfaces, there is a one package that is specifically designed to contain only functional interfaces that are reused in the rest of the library. That package is called java.util.function. Becoming familiar with these methods will make your job as a developer easier.

These interfaces fall into four basic categories, whose descriptions can be defined as follows:

Supplier

This interface is particularly simple. It takes no object as input, but returns an object. It does not have any static or default methods. It contains only a single, abstract method, T get(). The type of the returned object depends on what type parameter we use.

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

There are also suppliers of primitive types in java.util.function package. Following pre-defined Supplier functional interfaces are categorized as Supplier as all of these interfaces have the same behavior of supplying a result.

The lambda expression on the right side of the assignment operator must match the function interface type of the variable specified on the left side. One of the primary use cases for Supplier s is to support the concept of deferred execution.

Examples of using the Supplier:

The findFirst method on Stream returns the first encountered element in an ordered stream.

Optional<T> findFirst();

The orElse method on Optional returns either the contained element, or a specified default.

public T orElse(T other) {
    return value != null ? value : other;
}

The orElseGet method, however, takes a Supplier as an argument.

public T orElseGet(Supplier<? extends T> supplier) {
    return value != null ? value : supplier.get();
}

The orElseThrow method in Optional , which takes a Supplier . The Supplier is only executed if an exception occurs.

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    if (value != null) {
        return value;
    } else {
        throw exceptionSupplier.get();
    }
}

Objects.requireNonNull only customizes its response if the first argument is null.

public static <T> T requireNonNull(T obj, Supplier<String> messageSupplier) {
    if (obj == null)
       throw new NullPointerException(messageSupplier == null ? null : messageSupplier.get());
    return obj;
}

public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
    return asyncSupplyStage(ASYNC_POOL, supplier);
}

public void info(Supplier<String> msgSupplier) {
    log(Level.INFO, msgSupplier);
}

Practical example:

@FunctionalInterface
public interface Developer {
    String getStatus();
}

public class InterfaceDemo {
    public static void main(String[] args) {
        Developer developer = () -> "My status is ACTIVE";
        String status = developer.getStatus();
        System.out.println(status);
    }
}

The lambda expression constructed above is an implementation of the Supplier interface with a precisely defined type parameter. Therefore, we can write them in a different form:

public class InterfaceDemo {
    public static void main(String[] args) {
        Supplier<String> supplier = () -> "My status is ACTIVE";
        System.out.println(supplier.get());
    }
}

Since it has a specific type, we can use it as Java’s rules allow. For example, we can use it as the type of a method parameter. In this way, we can declare the execution of the method code in one place, and then realistically execute it in a completely different place. The execution consists in calling the get method of the Supplier interface. This makes sense because, as we know, we are dealing with a supplier and this is also how the method works, which has no parameters, but only returns a specific value.

public class InterfaceDemo {

    public static void main(String[] args) {
        Supplier<String> supplier = () -> "This is status ACTIVE";
        useSupplier(supplier);
    }

    public static void useSupplier(Supplier<String> supplier) {
        System.out.println(supplier.get());
    }
}

Consumer

It accepts an object on input, but returns nothing. The Consumer function interface has one abstract accept method and looks like this:

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

Optional.ifPresent(Consumer<? super T> consumer)

Stream.forEach(Consumer<? super T> action)

Stream.peek(Consumer<? super T> action)

@FunctionalInterface
public interface Programmer {
    void takeNumberAndPrint(Integer number);
}

public class InterfaceDemo {
    public static void main(String[] args) {
        Programmer programmer = System.out::println;
        programmer.takeNumberAndPrint(100);
    }
}

public class InterfaceDemo {

    public static void main(String[] args) {

        String programmerName = "Oskar";
        Integer programmerAge = 25;

        Consumer<Integer> printConsumer = number -> {
            System.out.printf("Hello %s", programmerName);
            boolean isEqual = programmerAge.equals(number);
            System.out.printf("\nResult: %b", isEqual);
        };
        executeConsumer(printConsumer);
    }

    static void executeConsumer(Consumer<Integer> consumer) {
        consumer.accept(100);
    }
}

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
    
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }

    static <T> Predicate<T> not(Predicate<? super T> target) {
        Objects.requireNonNull(target);
        return (Predicate<T>)target.negate();
    }
}

Optional.filter(Predicate<? super T> predicate)

Collection.removeIf(Predicate<? super E> filter)

Stream.allMatch(Predicate<? super T> predicate)

Collectors.partitioningBy(Predicate<? super T> predicate)

Predicates are useful whenever a stream should only return certain elements. This recipe hopefully gives you an idea where and when that might be useful.

@FunctionalInterface
public interface Worker<T> {
    boolean checkSomething(T t);
}

public class InterfaceDemo {
    public static void main(String[] args) {
        Worker<Integer> worker = x -> x == 5;
        boolean result = worker.checkSomething(2);
        System.out.printf("Result: %b", result);
    }
}

Of course, we can also prepare our own more complex interface that will meet the given assumptions using the default Predicate functional interface:

public class InterfaceDemo {

    public static void main(String[] args) {

        Predicate<String> predicate = x -> {
            boolean isOk = x.isEmpty();
            System.out.println(isOk
                    ? "The value meets the initial assumptions"
                    : "The value doesn't meet the initial assumptions");

            return isOk == (x.length() > 10);
        };
        usePredicate(predicate);
    }

    public static void usePredicate(Predicate<String> predicate) {
        predicate.test("Test");
    }
}

Note that for function interfaces that return a value for which the lambda expression does NOT contain a block statement (multi-line code), we do not use the return keyword. We immediately enter what is to be returned. On the other hand, when using a block statement, return is required at the end of the statement.

Function

Finally, we got to the strongest functional interface. Its power comes from the fact that it has a method that allows it to take a value on the input, return a value on the output, and these values can be of virtually any type. It takes an object on input and returns an object on output. The functional interface java.util.function.Function contains the single abstract method apply , which is invoked to transform a generic input parameter of type T into a generic output value of type R.

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
    
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

Following pre-defined Function functional interfaces are categorized as Function as all of these interfaces have the same behavior of accepting argument(s) and producing a result.

Examples of using Function

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)

<T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor)

<U extends Comparable<? super U>> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor)

Practical example

@FunctionalInterface
public interface Slaver {
    String executeTransformation(Integer number);
}

public class InterfaceDemo {

    public static void main(String[] args) {
        Slaver slaver = Object::toString;
        String result = slaver.executeTransformation(100);
        System.out.printf("Result: %s", result);
    }
}

Now let’s see what the implementation of such an interface will look like using a lambda expression. What should get your particular attention is the designation of the two types. The first is the type of the object taken as a parameter, and the second is the type of the object returned by the function.

We’ll do something simple to start with. The function method will analyze the given number, evaluate the set of numbers it belongs to, and return the result as a string.

public class InterfaceDemo {

    public static void main(String[] args) {

        Function<Integer, String> function = number -> {
            String info = "";
            info = String.join(",", info, number % 2 == 0 ? "EVEN" : "ODD");
            info = String.join(",", info, number >= 0 ? "POSITIVE" : "NEGATIVE");
            return info;
        };
        useFunction(function);
    }

    public static void useFunction(Function<Integer, String> function) {
        function.apply(10);
    }
}

Here we could also use a more specific type of object that is IntFunction<String>. In general, these types of block instructions are structured similarly to methods, so we can easily implement quite complex algorithms here. Remember to add a semicolon after you close the statement. Otherwise the code will not compile.

Operators

Functional interfaces categorized under Operator are specialized Function where the passed argument and result are of the same type.

Following pre-defined Operator functional interfaces are there that can be used in place of Function interfaces if returned value is same as the type of the passed argument(s). If argument of that function and return type are the same there can be use UnaryOperator which is defined in java.util.function as well. Of course, there are also other similar interfaces like IntUnaryOperator, DoubleUnaryOperator or LongUnaryOperator, for which the input and output arguments are (as you might expected) int, double and long.

Practical examples

The above list of operators is quite large, so I will not give an example for each element in the table. Here we will describe a few randomly selected poems with specific examples and their implementation. Let me give you some examples that I found myself using recently.

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {

    public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
    }

    public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
    }
}

@FunctionalInterface
public interface BiConsumer<T, U> {

    void accept(T t, U u);

    default BiConsumer<T, U> andThen(BiConsumer<? super T, ? super U> after) {
        Objects.requireNonNull(after);

        return (l, r) -> {
            accept(l, r);
            after.accept(l, r);
        };
    }
}

@FunctionalInterface
public interface BiProgrammer {
    void takeTwoValuesAndPrint(Integer first, Integer second);
}

public class InterfaceDemo {
    public static void main(String[] args) {
        BiProgrammer programmer = (x, y) -> System.out.printf("First: %s, Second: %s", x, y);
        programmer.takeTwoValuesAndPrint(100, 30);
    }
}

public class InterfaceDemo {

    public static void main(String[] args) {
        BiConsumer<Integer, String> consumer = (x, y) -> System.out.printf("Integer = %s \nString = %s", x, y);
        useBiConsumer(consumer);
    }

    public static void useBiConsumer(BiConsumer<Integer, String> consumer) {
        consumer.accept(123, "Your value");
    }
}

@FunctionalInterface
public interface BiFunction<T, U, R> {

    R apply(T t, U u);

    default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t, U u) -> after.apply(apply(t, u));
    }
}

In this way, we’ve gone through the four basic categories of functional interfaces