包java.util.function中函数接口的参数和return类型汇总
A summary of the parameters and return type of functional interfaces in the package java.util.function
我正在寻找 table 参数和 return 类型的所有接口的单一抽象方法 (SAM) java.util.function。
包java.util.function中共有43个接口。其中 35 个总结在下面的 "General" tables 中（由于 Whosebug 不支持 HTML tables，因此以明文形式编写）：
General 1
---------
-> Return Type
| R boolean void
V - ------- ----
T Function<T,R> Predicate<T> Consumer<T>
P int IntFunction<R> IntPredicate IntConsumer
a long LongFunction<R> LongPredicate LongConsumer
r double DoubleFunction<R> DoublePredicate DoubleConsumer
a T,U BiFunction<T,U,R> BiPredicate<T,U> BiConsumer<T,U>
m void Supplier<T> BooleanSupplier -
General 2
---------
-> Return Type
| int long double
V --- ---- ------
T ToIntFunction<T> ToLongFunction<T> ToDoubleFunction<T>
P int IntUnaryOperator IntToLongFunction IntToDoubleFunction
a long LongToIntFunction LongUnaryOperator LongToDoubleFunction
r double DoubleToIntFunction DoubleToLongFunction DoubleUnaryOperator
a T,U ToIntBiFunction<T,U> ToLongBiFunction<T,U> ToDoubleBiFunction<T,U>
m void IntSupplier LongSupplier DoubleSupplier
其余8个未包含在上述"General"table中的接口是：IntBinaryOperator、LongBinaryOperator、DoubleBinaryOperator、ObjIntConsumer<T> , ObjLongConsumer<T>, ObjDoubleConsumer<T>, UnaryOperator<T>, BinaryOperator<T>。它们显示在以下 table 中。为了便于对比，还展示了相关接口：
Operators
---------
-> Return Type
| R
V -
T Function<T,R>
UnaryOperator<T> = Function<T,T>
T,U BiFunction<T,U,R>
BinaryOperator<T> = BiFunction<T,T,T>
P
a int
r ---
a int IntUnaryOperator
m int,int IntBinaryOperator
e
t long
e ----
r long LongUnaryOperator
s long,long LongBinaryOperator
double
------
double DoubleUnaryOperator
double,double DoubleBinaryOperator
Consumers
---------
-> Return Type
| void
V ----
T Consumer<T>
int IntConsumer
long LongConsumer
P double DoubleConsumer
a T,U BiConsumer<T,U>
r T,int ObjIntConsumer<T>
a T,long ObjLongConsumer<T>
m T,double ObjDoubleConsumer<T>
备注
Supplier<T>的类型参数在源代码中是T（T是抽象方法的return类型）。但是，它适合此 table 中的 R 列，因为它实际上是相同的。
至于完成上面"General 1"table的右下角条目，java.lang.Runnable可以认为是void-void界面.
UnaryOperator<T> 是 Function<T,T>.
BinaryOperator<T> 是 BiFunction<T,T,T>
命名规则
与 SAM（单一抽象方法）的接口以 void 作为唯一参数，其名称中有 Consumer 后缀；
与 returns void 的 SAM 接口在其名称中具有 Supplier 后缀；
与 returns boolean 的 SAM 接口在其名称中具有 Predicate 后缀；
带有一个参数的 SAM 接口和 returns 相同类型的名称中有一个 UnaryOperator 后缀；
与 SAM 的接口采用两个相同类型的参数并且 returns 相同类型的名称中有一个 BinaryOperator 后缀；
所有其他接口的名称中都有一个 Function 后缀；
采用两个不同类型参数的 SAM 接口在其后缀前有一个 Bi 前缀（如 BiConsumer、BiPredicate 和 BiFunction).
以上table另一种格式（因为以上格式在移动设备上可能显示不佳）：
P
一个
r
一个
米
T
整数
长
双
T,U
无效
Return类型
R
-----------------
函数
IntFunction
长函数
双函数
双函数
供应商
P
一个
r
一个
米
T
整数
长
双
T,U
无效
Return类型
整数
--------------------
ToIntFunction
IntUnaryOperator
LongToIntFunction
DoubleToIntFunction
ToIntBiFunction
IntSupplier
P
一个
r
一个
米
T
整数
长
双
T,U
无效
Return类型
长
---------------------
ToLongFunction
IntToLongFunction
LongUnaryOperator
DoubleToLongFunction
ToLongBiFunction
LongSupplier
P
一个
r
一个
米
T
整数
长
双
T,U
无效
Return类型
双
------------------------
ToDoubleFunction
IntToDoubleFunction
LongToDoubleFunction
双元运算符
ToDoubleBiFunction
双供应商
P
一个
r
一个
米
T
整数
长
双
T,U
无效
Return类型
布尔值
----------------
谓词
IntPredicate
LongPredicate
DoublePredicate
双谓词
布尔型供应商
P
一个
r
一个
米
T
整数
长
双
T,U
无效
Return类型
无效
----------------
消费者
IntConsumer
长消费者
双重消费者
BiConsumer
-
这是包中所有 43 个接口的 table，加上其他一些没有table 的接口。这种安排应该可以很容易地看到包中的命名模式。 table 旨在用作 .java class 文件中的注释。在 eclipse 中打开文件（或任何其他 IDE 可以解析注释中的 class 名称）。您应该能够将鼠标悬停在名称上并查看他们的 java 文档。如果您 attached the java source code.
正确，ctrl-click 将打开接口源代码
（令人惊讶的是，这在 InteliJ 中似乎不起作用。如果我缺少设置，请告诉我。）
import java.util.function.Function; //Prevent "which package?" popups
import java.util.function.Predicate;
抽象方法声明 "throws Exception" 的接口用 *
表示
/* Param\Return void boolean R
---- ------- -
void Runnable BooleanSupplier Supplier<R>
void AutoCloseable* Callable<R>*
T Consumer<T> Predicate<T> Function<T,R>
R UnaryOperator<R>
T, U BiConsumer<T,U> BiPredicate<T,U> BiFunction<T,U,R>
R, R BinaryOperator<R>
int IntConsumer IntPredicate IntFunction<R>
T, int ObjIntConsumer<T>
long LongConsumer LongPredicate LongFunction<R>
T, long ObjLongConsumer<T>
double DoubleConsumer DoublePredicate DoubleFunction<R>
T, double ObjDoubleConsumer<T>
Param\Return int long double
--- ---- ------
void IntSupplier LongSupplier DoubleSupplier
T ToIntFunction<T> ToLongFunction<T> ToDoubleFunction<T>
T,U ToIntBiFunction<T,U> ToLongBiFunction<T,U> ToDoubleBiFunction<T,U>
int IntUnaryOperator IntToLongFunction IntToDoubleFunction
int, int IntBinaryOperator
long LongToIntFunction LongUnaryOperator LongToDoubleFunction
long, long LongBinaryOperator
double DoubleToIntFunction DoubleToLongFunction DoubleUnaryOperator
double, double DoubleBinaryOperator */
一些使用示例：
// Lambda using Runnable
new Thread(() -> System.out.println(Thread.currentThread().getName())).start();
Optional<String> opt = Optional.of("Meh");
// Lambda using Predicate<? super String>;
opt = opt.filter( s->s.equalsIgnoreCase("meh") );
System.out.println(opt+" <-- opt");
// Lambda using Consumer<? super String>;
opt.ifPresent( s->System.out.println(s) );
// Lambda using Function<? super String, ? extends String>;
opt = opt.map(s->s+"!").map(s->s+"!");
System.out.println(opt+" <-- opt");
// Lambda using Supplier<? extends IllegalArgumentException>;
opt.orElseThrow( ()->new IllegalArgumentException("Should not be empty.") );
opt = Optional.empty();
opt.orElseThrow(
()->new IllegalArgumentException("Empty? Who said you could be empty?")
);
Thread-0
Optional[Meh] <-- opt
Meh
Optional[Meh!!] <-- opt
Exception in thread "main" java.lang.IllegalArgumentException:
Empty? Who said you could be empty?
at functionalinterfacestudy.AllLambdas.lambda(AllLambdas.java:110)
at functionalinterfacestudy.AllLambdas$$Lambda/1392838282.get(Unknown Source)
at java.util.Optional.orElseThrow(Unknown Source)
at functionalinterfacestudy.AllLambdas.main(AllLambdas.java:110)
此外，本书还赠送了一些detailed tables。
而且，虽然它不是 table，但阅读 official package summery 总是好的。
JDK 实际上有 57 个接口支持 @FunctionalInterface annotation。上面没有提到的包括：
import java.io.FileFilter; // Aren't name collisions fun?
import java.io.FilenameFilter;
import java.util.Comparator;
import java.util.logging.Filter;
/*
Interface Single Abstract Method
--------- ----------------------
KeyEventDispatcher: boolean dispatchKeyEvent(KeyEvent e);
KeyEventPostProcessor: boolean postProcessKeyEvent(KeyEvent e);
FileFilter: boolean accept(File pathname);
FilenameFilter: boolean accept(File dir, String name);
Thread.UncaughtExceptionHandler: void uncaughtException(Thread t, Throwable e);
DirectoryStream<T>.Filter<T>: boolean accept(T entry) throws IOException;
PathMatcher: boolean matches(Path path);
TemporalAdjuster: Temporal adjustInto(Temporal temporal);
TemporalQuery<R>: R queryFrom(TemporalAccessor temporal);
Comparator<T>: int compare(T o1, T o2);
Filter: public boolean isLoggable(LogRecord record);
PreferenceChangeListener: void preferenceChange(PreferenceChangeEvent evt);
*/
然而，JDK有许多接口满足成为功能接口的所有要求，但没有@FunctionalInterface注释（例如AutoClosable）。缺少的注释不会阻止它们作为功能接口工作。它用于在接口违反功能接口的定义时强制编译器抛出错误。在某种程度上，它承诺在实现接口时不扩展必须重写的抽象方法集（可以添加默认方法，因为它们总是有自己的实现）。这让我想知道：
我正在寻找 table 参数和 return 类型的所有接口的单一抽象方法 (SAM) java.util.function。
包java.util.function中共有43个接口。其中 35 个总结在下面的 "General" tables 中（由于 Whosebug 不支持 HTML tables，因此以明文形式编写）：
General 1
---------
-> Return Type
| R boolean void
V - ------- ----
T Function<T,R> Predicate<T> Consumer<T>
P int IntFunction<R> IntPredicate IntConsumer
a long LongFunction<R> LongPredicate LongConsumer
r double DoubleFunction<R> DoublePredicate DoubleConsumer
a T,U BiFunction<T,U,R> BiPredicate<T,U> BiConsumer<T,U>
m void Supplier<T> BooleanSupplier -
General 2
---------
-> Return Type
| int long double
V --- ---- ------
T ToIntFunction<T> ToLongFunction<T> ToDoubleFunction<T>
P int IntUnaryOperator IntToLongFunction IntToDoubleFunction
a long LongToIntFunction LongUnaryOperator LongToDoubleFunction
r double DoubleToIntFunction DoubleToLongFunction DoubleUnaryOperator
a T,U ToIntBiFunction<T,U> ToLongBiFunction<T,U> ToDoubleBiFunction<T,U>
m void IntSupplier LongSupplier DoubleSupplier
其余8个未包含在上述"General"table中的接口是：IntBinaryOperator、LongBinaryOperator、DoubleBinaryOperator、ObjIntConsumer<T> , ObjLongConsumer<T>, ObjDoubleConsumer<T>, UnaryOperator<T>, BinaryOperator<T>。它们显示在以下 table 中。为了便于对比，还展示了相关接口：
Operators
---------
-> Return Type
| R
V -
T Function<T,R>
UnaryOperator<T> = Function<T,T>
T,U BiFunction<T,U,R>
BinaryOperator<T> = BiFunction<T,T,T>
P
a int
r ---
a int IntUnaryOperator
m int,int IntBinaryOperator
e
t long
e ----
r long LongUnaryOperator
s long,long LongBinaryOperator
double
------
double DoubleUnaryOperator
double,double DoubleBinaryOperator
Consumers
---------
-> Return Type
| void
V ----
T Consumer<T>
int IntConsumer
long LongConsumer
P double DoubleConsumer
a T,U BiConsumer<T,U>
r T,int ObjIntConsumer<T>
a T,long ObjLongConsumer<T>
m T,double ObjDoubleConsumer<T>
备注
Supplier<T>的类型参数在源代码中是T（T是抽象方法的return类型）。但是，它适合此 table 中的R列，因为它实际上是相同的。至于完成上面"General 1"table的右下角条目，
java.lang.Runnable可以认为是void-void界面.UnaryOperator<T>是Function<T,T>. 的别名（Java 术语中的子接口）
BinaryOperator<T>是BiFunction<T,T,T> 的别名（Java 术语中的子接口）
命名规则
与 SAM（单一抽象方法）的接口以
void作为唯一参数，其名称中有Consumer后缀；与 returns
void的 SAM 接口在其名称中具有Supplier后缀；与 returns
boolean的 SAM 接口在其名称中具有Predicate后缀；带有一个参数的 SAM 接口和 returns 相同类型的名称中有一个
UnaryOperator后缀；与 SAM 的接口采用两个相同类型的参数并且 returns 相同类型的名称中有一个
BinaryOperator后缀；所有其他接口的名称中都有一个
Function后缀；采用两个不同类型参数的 SAM 接口在其后缀前有一个
Bi前缀（如BiConsumer、BiPredicate和BiFunction).
以上table另一种格式（因为以上格式在移动设备上可能显示不佳）：
P
一个
r
一个
米
T
整数
长
双
T,U
无效
Return类型
R
-----------------
函数
IntFunction
长函数
双函数
双函数
供应商
P
一个
r
一个
米
T
整数
长
双
T,U
无效
Return类型
整数
--------------------
ToIntFunction
IntUnaryOperator
LongToIntFunction
DoubleToIntFunction
ToIntBiFunction
IntSupplier
P
一个
r
一个
米
T
整数
长
双
T,U
无效
Return类型
长
---------------------
ToLongFunction
IntToLongFunction
LongUnaryOperator
DoubleToLongFunction
ToLongBiFunction
LongSupplier
P
一个
r
一个
米
T
整数
长
双
T,U
无效
Return类型
双
------------------------
ToDoubleFunction
IntToDoubleFunction
LongToDoubleFunction
双元运算符
ToDoubleBiFunction
双供应商
P
一个
r
一个
米
T
整数
长
双
T,U
无效
Return类型
布尔值
----------------
谓词
IntPredicate
LongPredicate
DoublePredicate
双谓词
布尔型供应商
P
一个
r
一个
米
T
整数
长
双
T,U
无效
Return类型
无效
----------------
消费者
IntConsumer
长消费者
双重消费者
BiConsumer
-
这是包中所有 43 个接口的 table，加上其他一些没有table 的接口。这种安排应该可以很容易地看到包中的命名模式。 table 旨在用作 .java class 文件中的注释。在 eclipse 中打开文件（或任何其他 IDE 可以解析注释中的 class 名称）。您应该能够将鼠标悬停在名称上并查看他们的 java 文档。如果您 attached the java source code.
正确，ctrl-click 将打开接口源代码
（令人惊讶的是，这在 InteliJ 中似乎不起作用。如果我缺少设置，请告诉我。）
import java.util.function.Function; //Prevent "which package?" popups
import java.util.function.Predicate;
抽象方法声明 "throws Exception" 的接口用 *
表示/* Param\Return void boolean R
---- ------- -
void Runnable BooleanSupplier Supplier<R>
void AutoCloseable* Callable<R>*
T Consumer<T> Predicate<T> Function<T,R>
R UnaryOperator<R>
T, U BiConsumer<T,U> BiPredicate<T,U> BiFunction<T,U,R>
R, R BinaryOperator<R>
int IntConsumer IntPredicate IntFunction<R>
T, int ObjIntConsumer<T>
long LongConsumer LongPredicate LongFunction<R>
T, long ObjLongConsumer<T>
double DoubleConsumer DoublePredicate DoubleFunction<R>
T, double ObjDoubleConsumer<T>
Param\Return int long double
--- ---- ------
void IntSupplier LongSupplier DoubleSupplier
T ToIntFunction<T> ToLongFunction<T> ToDoubleFunction<T>
T,U ToIntBiFunction<T,U> ToLongBiFunction<T,U> ToDoubleBiFunction<T,U>
int IntUnaryOperator IntToLongFunction IntToDoubleFunction
int, int IntBinaryOperator
long LongToIntFunction LongUnaryOperator LongToDoubleFunction
long, long LongBinaryOperator
double DoubleToIntFunction DoubleToLongFunction DoubleUnaryOperator
double, double DoubleBinaryOperator */
一些使用示例：
// Lambda using Runnable
new Thread(() -> System.out.println(Thread.currentThread().getName())).start();
Optional<String> opt = Optional.of("Meh");
// Lambda using Predicate<? super String>;
opt = opt.filter( s->s.equalsIgnoreCase("meh") );
System.out.println(opt+" <-- opt");
// Lambda using Consumer<? super String>;
opt.ifPresent( s->System.out.println(s) );
// Lambda using Function<? super String, ? extends String>;
opt = opt.map(s->s+"!").map(s->s+"!");
System.out.println(opt+" <-- opt");
// Lambda using Supplier<? extends IllegalArgumentException>;
opt.orElseThrow( ()->new IllegalArgumentException("Should not be empty.") );
opt = Optional.empty();
opt.orElseThrow(
()->new IllegalArgumentException("Empty? Who said you could be empty?")
);
Thread-0
Optional[Meh] <-- opt
Meh
Optional[Meh!!] <-- opt
Exception in thread "main" java.lang.IllegalArgumentException:
Empty? Who said you could be empty?
at functionalinterfacestudy.AllLambdas.lambda(AllLambdas.java:110)
at functionalinterfacestudy.AllLambdas$$Lambda/1392838282.get(Unknown Source)
at java.util.Optional.orElseThrow(Unknown Source)
at functionalinterfacestudy.AllLambdas.main(AllLambdas.java:110)
此外，本书还赠送了一些detailed tables。
而且，虽然它不是 table，但阅读 official package summery 总是好的。
JDK 实际上有 57 个接口支持 @FunctionalInterface annotation。上面没有提到的包括：
import java.io.FileFilter; // Aren't name collisions fun?
import java.io.FilenameFilter;
import java.util.Comparator;
import java.util.logging.Filter;
/*
Interface Single Abstract Method
--------- ----------------------
KeyEventDispatcher: boolean dispatchKeyEvent(KeyEvent e);
KeyEventPostProcessor: boolean postProcessKeyEvent(KeyEvent e);
FileFilter: boolean accept(File pathname);
FilenameFilter: boolean accept(File dir, String name);
Thread.UncaughtExceptionHandler: void uncaughtException(Thread t, Throwable e);
DirectoryStream<T>.Filter<T>: boolean accept(T entry) throws IOException;
PathMatcher: boolean matches(Path path);
TemporalAdjuster: Temporal adjustInto(Temporal temporal);
TemporalQuery<R>: R queryFrom(TemporalAccessor temporal);
Comparator<T>: int compare(T o1, T o2);
Filter: public boolean isLoggable(LogRecord record);
PreferenceChangeListener: void preferenceChange(PreferenceChangeEvent evt);
*/
然而，JDK有许多接口满足成为功能接口的所有要求，但没有@FunctionalInterface注释（例如AutoClosable）。缺少的注释不会阻止它们作为功能接口工作。它用于在接口违反功能接口的定义时强制编译器抛出错误。在某种程度上，它承诺在实现接口时不扩展必须重写的抽象方法集（可以添加默认方法，因为它们总是有自己的实现）。这让我想知道：