Functional Interfaces

A functional interface is an interface that declares exactly one abstract method, making it a valid target type for a lambda expression or method reference. Java 8 added the @FunctionalInterface annotation and a full set of general-purpose functional interfaces in the java.util.function package so that developers rarely need to declare their own.

Why it matters

Every lambda has a type, and that type is a functional interface. The four you will meet constantly are Predicate, Function, Consumer and Supplier: they are the parameter types of the Stream API and of much of modern Java. Recognising them tells you at once what kind of lambda a method expects.

The Single Abstract Method Rule

A functional interface can have any number of default methods and static methods, but only one abstract method — that single method is what the lambda's parameter list and body actually implement. The @FunctionalInterface annotation is optional but strongly recommended: it tells the compiler to raise an error if a second abstract method is accidentally added, catching the mistake at compile time instead of at the point of use.

Core Built-in Functional Interfaces

Rather than defining custom interfaces for common shapes of behavior, Java 8 ships a standard set in java.util.function:

• Predicate<T> — boolean test(T t), used for conditions/filters.
• Function<T, R> — R apply(T t), transforms a value of type T into type R.
• Supplier<T> — T get(), takes no arguments and produces a value.
• Consumer<T> — void accept(T t), takes a value and performs an action, returning nothing.
• BiFunction<T, U, R> — R apply(T t, U u), like Function but with two input arguments.

Writing a Custom Functional Interface

When none of the built-in interfaces fit — for example, you want meaningful parameter names in the API or a domain-specific method name — you can declare your own single-abstract-method interface and annotate it with @FunctionalInterface for safety and clarity.

Example

import java.util.function.Predicate;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.function.Consumer;
import java.util.function.BiFunction;

public class FunctionalInterfaceDemo {

    @FunctionalInterface
    interface Greeter {
        String greet(String name);
    }

    public static void main(String[] args) {
        Predicate<Integer> isEven = n -> n % 2 == 0;
        Function<String, Integer> length = String::length;
        Supplier<String> greeting = () -> "Hello from Supplier";
        Consumer<String> printer = s -> System.out.println("Consumed: " + s);
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;

        System.out.println(isEven.test(4));
        System.out.println(length.apply("Webnest"));
        System.out.println(greeting.get());
        printer.accept("data");
        System.out.println(add.apply(2, 3));

        Greeter greeter = name -> "Welcome, " + name + "!";
        System.out.println(greeter.greet("Asha"));
    }
}

true
7
Hello from Supplier
Consumed: data
5
Welcome, Asha!

Exercise

Define a Predicate that tests whether a number is even and a Function that squares a number. Print the result of testing 4, of squaring 5, and of testing 4 with the predicate negated.

Expected output: true, 25, false (one per line)

import java.util.function.Function;
import java.util.function.Predicate;

public class BuiltInInterfaces {
    public static void main(String[] args) {
        // TODO: Predicate<Integer> isEven
        // TODO: Function<Integer, Integer> square

        // TODO: print isEven for 4, square of 5, and the negated predicate for 4
    }
}

import java.util.function.Function;
import java.util.function.Predicate;

public class BuiltInInterfaces {
    public static void main(String[] args) {
        Predicate<Integer> isEven = n -> n % 2 == 0;
        Function<Integer, Integer> square = n -> n * n;

        System.out.println(isEven.test(4));          // true
        System.out.println(square.apply(5));         // 25
        System.out.println(isEven.negate().test(4)); // false
    }
}

Quick quiz

Interview questions