Detailed explanation of common functional interfaces (delegates) in Java

Little scum · Posted on 9/16/2021 9:28:21 AM

The JDK 1.8 API includes many built-in functional interfaces, such as the Comparator or Runnable interfaces commonly used in old Java, which add @FunctionalInterface annotations so that they can be used on lambdas. Now, let's really understand it from the entrance of common functions in Function.

name	type	description
Consumer	Consumer< T >	Receives T objects, does not return values
Predicate	Predicate< T >	Receives the T object and returns the boolean
Function	Function< T, R >	Receives T object and returns R object
Supplier	Supplier< T >	Provide T objects (e.g. plants) without accepting values
UnaryOperator	UnaryOperator	Receives T object and returns T object
BinaryOperator	BinaryOperator	Receive two T objects and return T objects

An interface labeled as a FunctionalInterface is called a functional interface, which can only have one custom method, but can include methods inherited from the object class. If an interface has only one method, the compiler will think that it is a functional interface. Whether it is a functional interface or not, the following points need to be noted:

The annotation can only be marked on interfaces with "There is only one abstract method".
The static and default methods in the JDK8 interface are not abstract methods.
The interface inherits java.lang.Object by default, so if the interface shows that the declaration overrides the method in the Object, it is not considered an abstract method.
The annotation is not required, and if an interface meets the definition of a "functional interface", it has no effect whether the annotation is added or not. Plus the annotation allows the compiler to check better. If you write a non-functional interface, but add @FunctionInterface, the compiler will report an error.
Defining two custom methods in one interface will result in an Invalid '@FunctionalInterface' annotation; FunctionalInterfaceTest is not a functional interface error.

java.util.function It contains a number of classes to support Java's functional programming, and the functional interfaces in this package are:

serial number	Interface & Description
1	BiConsumer<T,U> Represents an action that accepts two input parameters and returns no results
2	BiFunction<T,U,R> Represents a method that accepts two input parameters and returns a result
3	BinaryOperator<T> represents an action that acts on two operators of the same type, and returns the result of the same type of operator
4	BiPredicate<T,U> Represents a two-parameter boolean value method
5	BooleanSupplier Represents the provider of the boolean value result
6	Consumer<T> Represents an operation that accepts an input parameter and returns nothing
7	DoubleBinaryOperator represents an action that acts on two double-valued operators, and returns the result of a double-value.
8	DoubleConsumer Represents an action that accepts a double value parameter and does not return a result.
9	DoubleFunction<R> Represents a method that accepts a double-valued parameter and returns the result
10	DoublePredicate Represents a boolean value method with a double value parameter
11	DoubleSupplier Represents the provider of a double-value structure
12	DoubleToIntFunction Accepts a double-type input and returns an int-type result.
13	DoubleToLongFunction Accepts a double-type input and returns a long-type result
14	DoubleUnaryOperator Accept a parameter of the same type double, and the return value type is also double.
15	Function<T,R> Accepts an input parameter, returns a result.
16	IntBinaryOperator Accept both parameters of type int, and return value type int.
17	IntConsumer Accepts an input parameter of type int with no return value.
18	IntFunction<R> Accepts an int type input parameter and returns a result.
19	IntPredicate : Accepts an int input parameter and returns a boolean result.
20	IntSupplier No parameters, returns an int type result.
21	IntToDoubleFunction Accepts an int type input and returns a double type result.
22	IntToLongFunction Accepts an int type input and returns a long type result.
23	IntUnaryOperator Accept a parameter of type int, and return the value type is also int.
24	LongBinaryOperator Accept both parameters of type long and return value type as long.
25	LongConsumer Accept an input parameter of type long with no return value.
26	LongFunction<R> Accepts a long type input parameter and returns a result.
27	LongPredicate R accepts a long input parameter and returns a boolean type result.
28	LongSupplier No parameter, returns a result of type long.
29	LongToDoubleFunction Accepts a long type input and returns a double type result.
30	LongToIntFunction Accepts a long type input and returns an int type result.
31	LongUnaryOperator Accept a parameter of the same type as long, and return the value of type is also long.
32	ObjDoubleConsumer<T> Accept an object type and a double type input parameter with no return value.
33	ObjIntConsumer<T> Accept input parameters of type object and type int with no return value.
34	ObjLongConsumer<T> Accepts input parameters of type object and type long without returning values.
35	Predicate<T> Accepts an input parameter and returns a Boolean result.
36	Supplier<T> No parameters, returns a result.
37	ToDoubleBiFunction<T,U> Accepts two input parameters and returns a double-type result
38	ToDoubleFunction<T> Accepts an input parameter and returns a double-type result
39	ToIntBiFunction<T,U> Accept two input parameters and return an int type result.
40	ToIntFunction<T> Accept an input parameter and return an int type result.
41	ToLongBiFunction<T,U> Accept two input parameters and return a long-type result.
42	ToLongFunction<T> Accept an input parameter and return a long type result.
43	UnaryOperator<T> Accept a parameter of type T and return the value of type T.

IThe functional interface in Java is the delegate in .NET/C#, pass the method as a parameter, as follows:

Introduction to C# delegates (delegate, Action, Func, predicate)
https://www.itsvse.com/thread-4658-1-1.html

Function Common Methods && Practices

//将Function对象应用到输入的参数上，然后返回计算结果。
R apply(T t);

Although Function< T, R > receive T objects, return R objects, and only one receive and return objects, but combined with tuples, multiple incoming and returning values can be achieved, refer to: