Package java.util.function

1. Commonly Used Functional Interfaces

Java SE 8 has added a lot of common functional interfaces, which can be used by the developer in lambda expressions instead of creating their own. They are defined in java.util.function package.

The most commonly used functional interfaces are:

2. Binary Specializations

The Predicate, Consumer, Function, and UnaryOperator functional interfaces represent an operation that takes one argument. But there are versions of these interfaces that take two arguments, called. These are the binary versions. They have the same semantics, the only difference is the number of arguments. Note, there is no binary version of the Supplier. This is because a Supplier takes no arguments.

The binary versions of the functional interfaces are:

3. Primitive Specializations

Every Java type is either a reference type (for example, String, Long, Object, List) or a primitive type (for example, int, long, char, boolean). But generic parameters (for example, the T in Supplier) can be bound only to reference types.

Java has a mechanism to convert a primitive type into a corresponding reference type (boxing) and a mechanism to convert a reference type into a corresponding primitive type (unboxing). An autoboxing mechanism facilitates boxing and unboxing operations for developers.

But this comes with a performance cost. Boxed values are essentially a wrapper around primitive types and are stored on the heap. Therefore, boxed values use more memory and require additional memory lookups to fetch the wrapped primitive value. Java 8 brings a specialized version of the functional interfaces in order to avoid autoboxing operations when the inputs or outputs are primitives. For example, in the following code, using an IntConsumer avoids a boxing operation of the value:

@FunctionalInterface
public interface IntConsumer {
    void accept(int value);
    ...
}

IntConsumer ic = i -> System.out.println(++i);
ic.accept(8);
ic.accept(9);

The names of functional interfaces that have a specialization for the input type parameter are preceded by the appropriate primitive type, for example, IntFunction, DoublePredicate, LongBinaryOperator, IntConsumer. The Function interface has also variants for the output type parameter: ToIntFunction, ToDoubleFunction.

3.1. Predicate<T> Primitive Specializations

Function Descriptor: T -> boolean

3.2. Consumer<T> Primitive Specializations

Function Descriptor: T -> void

3.3. Function<T, R> Primitive Specializations

Function Descriptor: T -> R

The Function interface has variants not only for the input type parameters but for output and input/output as well. They are divided into three separate tables:

3.4. Supplier<T> Primitive Specializations

Function Descriptor: () -> T

3.5. UnaryOperator<T> Primitive Specializations

Function Descriptor: T -> T

3.6. BinaryOperator<T> Primitive Specializations

Function Descriptor: (T, T) -> T

3.7. BiConsumer<T, U> Primitive Specializations

Function Descriptor: (T, U) -> void

3.8. BiFunction<T, U, R> Primitive Specializations

Function Descriptor: (T, U) -> R