Predicate vs Function vs Consumer vs Supplier

They are the four core functional interfaces in java.util.function, and they differ in what goes in and what comes out.

Predicate<T> takes one value and returns a boolean. Its method is test. It models a yes-or-no question and is what you pass to filter and removeIf.

Function<T, R> takes one value and returns a value of a different type. Its method is apply. It models a transformation, and it is what you pass to map.

Consumer<T> takes one value and returns nothing. Its method is accept. It models a side effect — logging, printing, writing somewhere — and it is what you pass to forEach.

Supplier<T> takes nothing and returns a value. Its method is get. It models a supplier of values, and it is what you pass to orElseGet or to a lazy initialiser.

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

public class Main {
    public static void main(String[] args) {
        Predicate<String> notEmpty = s -> !s.isEmpty();
        Function<String, Integer> length = String::length;
        Consumer<String> printer = s -> System.out.println("consumed: " + s);
        Supplier<String> supplier = () -> "produced on demand";

        System.out.println("predicate: " + notEmpty.test("hello"));
        System.out.println("function : " + length.apply("hello"));
        printer.accept("hello");
        System.out.println("supplier : " + supplier.get());
    }
}

The output shows each one doing its own job: the Predicate answers a question, the Function produces a transformed value, the Consumer performs an action with no result, and the Supplier produces a value from nothing.

There are two more worth knowing. BiFunction, BiConsumer and BiPredicate take two arguments, and the UnaryOperator and BinaryOperator specialisations of Function take an argument of the same type they return, which is what you want for a transform such as doubling.

Function and Supplier return a value. Predicate and Consumer do not.

Function<T, R> takes a T and returns an R. Supplier<T> takes nothing and returns a T. Predicate<T> takes a T and returns a boolean, which is a value but not a value you use — it is a decision the caller branches on. Consumer<T> takes a T and returns void, so it can only have an effect.

That difference has practical consequences. A Consumer cannot be chained, because there is nothing to chain onto — the next stage has no input. A Predicate and a Function can both be combined, and the library provides default methods for it: Predicate has and, or and negate, and Function has andThen and compose. A Supplier has no natural combinator, but it plugs into Optional.orElseGet, which takes exactly a Supplier and only calls it when the value is absent — which is precisely why that overload exists alongside the eager orElse.

One more detail worth knowing: Predicate and Function have primitive specialisations for performance. IntPredicate, LongPredicate and DoublePredicate avoid the boxing that a Predicate<Integer> would incur, and the same pattern exists for the Function family. The library uses them internally in the stream API for exactly that reason.

Each stage of a stream pipeline wants a different shape of functional interface, and naming them separately is what keeps the pipeline readable. The Predicate decides what stays, the Function transforms what stays, and the Consumer does something with the result.

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

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("Java", "python", "JAVA", "kotlin", "java");

        Predicate<String> shortEnough = w -> w.length() <= 4;
        Function<String, String> normalise = w -> w.toLowerCase();
        Consumer<String> reporter = w -> System.out.println("kept: " + w);

        words.stream()
             .filter(shortEnough)
             .map(normalise)
             .forEach(reporter);
    }
}

The output shows the two words that survived both the length filter and the normalisation — Java and JAVA both became java, and python and kotlin were filtered out because they are longer than four characters.

Each functional interface also has its own composition method, and using them turns a long inline lambda into something you can name. Predicate gives you and, or and negate. Function gives you andThen for running one after another and compose for running one before another. And you can define your own tiny interfaces when the standard four do not fit, which is often a better answer than writing a long lambda with several parameters.

Two practical warnings. A Predicate must be side-effect free, because a stream may evaluate it more than once and in any order. And if you find yourself writing a long inline lambda in a filter or a map, extract it into a named variable or a method reference — the named version documents the intent and is far easier to test.