Package java.util.function

Functional interfaces provide target types for lambda expressions and method references.

See: Description

Interface Summary

Interface	Description
BiConsumer<T,U>	An operation which accepts two input arguments and returns no result.
BiFunction<T,U,R>	Apply a function to the input arguments, yielding an appropriate result.
BinaryOperator<T>	An operation upon two operands yielding a result.
BiPredicate<T,U>	Determines if the input objects match some criteria.
BooleanSupplier	A supplier of boolean values.
Consumer<T>	An operation which accepts a single input argument and returns no result.
DoubleBinaryOperator	An operation on two double operands yielding a double result.
DoubleConsumer	An operation which accepts a single double argument and returns no result.
DoubleFunction<R>	Apply a function to the double-valued input argument, yielding an appropriate result.
DoublePredicate	Determines if the double input value matches some criteria.
DoubleSupplier	A supplier of double values.
DoubleToIntFunction	Apply a function to the input argument, yielding an appropriate result.
DoubleToLongFunction	Apply a function to the input argument, yielding an appropriate result.
DoubleUnaryOperator	An operation on a double operand yielding a double result.
Function<T,R>	Apply a function to the input argument, yielding an appropriate result.
IntBinaryOperator	An operation on two int operands yielding an int result.
IntConsumer	An operation which accepts a single integer argument and returns no result.
IntFunction<R>	Apply a function to the integer-valued input argument, yielding an appropriate result.
IntPredicate	Determines if the int input value matches some criteria.
IntSupplier	A supplier of int values.
IntToDoubleFunction	Apply a function to the input argument, yielding an appropriate result.
IntToLongFunction	Apply a function to the input argument, yielding an appropriate result.
IntUnaryOperator	An operation on a single int operand yielding an int result.
LongBinaryOperator	An operation on two long operands yielding a long result.
LongConsumer	An operation which accepts a single long argument and returns no result.
LongFunction<R>	Apply a function to the long-valued input argument, yielding an appropriate result.
LongPredicate	Determines if the long input value matches some criteria.
LongSupplier	A supplier of long values.
LongToDoubleFunction	Apply a function to the input argument, yielding an appropriate result.
LongToIntFunction	Apply a function to the input argument, yielding an appropriate result.
LongUnaryOperator	An operation on a single long operand yielding a long result.
ObjDoubleConsumer<T>	An operation which accepts an object reference and a double, and returns no result.
ObjIntConsumer<T>	An operation which accepts an object reference and an int, and returns no result.
ObjLongConsumer<T>	An operation which accepts an object reference and a long, and returns no result.
Predicate<T>	Determines if the input object matches some criteria.
Supplier<T>	A supplier of objects.
ToDoubleBiFunction<T,U>	Apply a function to the input arguments, yielding an appropriate result.
ToDoubleFunction<T>	Apply a function to the input argument, yielding an appropriate result.
ToIntBiFunction<T,U>	Apply a function to the input arguments, yielding an appropriate result.
ToIntFunction<T>	Apply a function to the input argument, yielding an appropriate result.
ToLongBiFunction<T,U>	Apply a function to the input arguments, yielding an appropriate result.
ToLongFunction<T>	Apply a function to the input argument, yielding an appropriate result.
UnaryOperator<T>	An operation upon a single operand yielding a result.

Package java.util.function Description

Functional interfaces provide target types for lambda expressions and method references. Each functional interface has a single abstract method to which the lambda expression's parameter and return types are matched or adapted. Functional interfaces can provide a target type in multiple contexts, such as assignment context, method invocation, or cast context:

     Predicate<String> p = String::isEmpty;

     stream.filter(e -> e.getSize() > 10)...

     stream.map((ToIntFunction) e -> e.getSize())...
 

The interfaces in this package are functional interfaces used by the JDK, and are available to be used by user code as well. While they do not identify a complete set of function shapes to which lambda expressions might be adapted, they provide enough to cover common requirements.

The interfaces in this package are annotated with @{link FunctionalInterface}. This annotation is not a requirement for the compiler to recognize an interface as a functional interface, but merely an aid to capture design intent and enlist the help of the compiler in identifying accidental violations of design intent.

The functional interfaces in this package follow an extensible naming convention, as follows:

• There are several basic function shapes, including Function (T -> R), Consumer (T -> void), Predicate (T -> boolean), and Supplier (() -> T).
• Function shapes have a natural arity based on how they are most commonly used. The basic shapes can be modified by an arity prefix to indicate a different arity, such as BiFunction ((T, U) -> R).
• There are additional derived function shapes which extend the basic function shapes, including UnaryOperator (extends Function) and BinaryOperator (extends BiFunction).
• Type parameters of functional interfaces can be specialized to primitives with additional type prefixes. To specialize the return type for a type that has both generic return type and generic arguments, we prefix ToXxx, as in ToIntFunction. Otherwise, type arguments are specialized left-to-right, as in DoubleConsumer or ObjIntConsumer. (The type prefix Obj is used to indicate that we don't want to specialize this parameter, but want to move on to the next parameter.) These schemes can be combined as in IntToDoubleFunction.
• If there are specialization prefixes for all arguments, the arity prefix may be left out (as in ObjIntConsumer).

See Also:

FunctionalInterface