我正在寻找. 中所有接口的单个抽象方法 (SAM) 的参数和返回类型表java.util.function。
问问题
2524 次
2 回答
11
这是包中所有 43 个接口的表格，以及其他一些值得注意的接口。这种安排应该可以很容易地看到包中的命名模式。该表旨在用作 .java 类文件中的注释。在 eclipse（或任何其他可以解析注释中的类名的 IDE）中打开文件。您应该能够将鼠标悬停在名称上并查看它们的 javadocs。ctrl-click如果您正确附加了 java 源代码， A将打开接口源代码。
（令人惊讶的是，这似乎在 InteliJ 中不起作用。如果我缺少某个设置，请告诉我。）
import java.util.function.Function; //Prevent "which package?" popups
import java.util.function.Predicate;
抽象方法声明“抛出异常”的接口，用 * 表示
/* 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$6(AllLambdas.java:110)
at functionalinterfacestudy.AllLambdas$$Lambda$7/1392838282.get(Unknown Source)
at java.util.Optional.orElseThrow(Unknown Source)
at functionalinterfacestudy.AllLambdas.main(AllLambdas.java:110)
此外，本书还提供了包含一些详细表格的软件包。
而且，虽然它不是一张桌子，但阅读官方包装summery总是很好的。
JDK 实际上有 57 个带有@FunctionalInterface 注释的接口。以上未提及的包括：
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）。缺少的注释不会阻止它们作为功能接口工作。当接口违反功能接口的定义时，它用于强制编译器抛出错误。在某种程度上，承诺不会扩展您在实现接口时必须覆盖的抽象方法集（可以添加默认方法，因为它们总是有自己的实现）。这让我想知道：为什么它没有@FunctionalInterface在 JDK 中符合条件的所有接口上使用？
于 2015-01-27T03:24:53.727 回答
4
包中一共有43个接口java.util.function。其中 35 个总结在下面的“常规”表格中（由于 StackOverflow 不支持 HTML 表格，所以它以明文形式编写）：
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 个接口是：IntBinaryOperator、LongBinaryOperator、DoubleBinaryOperator、ObjIntConsumer<T>、ObjLongConsumer<T>、ObjDoubleConsumer<T>、UnaryOperator<T>、BinaryOperator<T>。它们如下表所示。为了便于比较，还显示了相关接口：
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是抽象方法的返回类型）。但是，它适合R此表中的列，因为它实际上是相同的。至于完成上面“General 1”表的右下角条目，
java.lang.Runnable可以认为是一个void-void接口。UnaryOperator<T>是 的别名（Java 术语中的子接口）Function<T,T>。BinaryOperator<T>是一个别名（Java 术语中的子接口）BiFunction<T,T,T>
命名规则
void带有作为唯一参数的SAM（单一抽象方法）的接口Consumer在其名称中带有后缀；返回的带有 SAM 的接口在其名称
void中带有Supplier后缀；返回的带有 SAM 的接口在其名称
boolean中带有Predicate后缀；带有一个参数并返回相同类型的 SAM 接口在其名称中具有
UnaryOperator后缀；带有两个相同类型参数并返回相同类型的 SAM 接口
BinaryOperator在其名称中带有后缀；所有其他接口的名称都有
Function后缀；带有两个不同类型参数的 SAM 接口
Bi在其后缀之前有一个前缀（如BiConsumer,BiPredicate和BiFunction）。
上表的另一种格式（因为上表在移动设备中可能无法很好地显示）：
P
a
r
a
m
T
int
long
double
T,U
void
Return Type
R
-----------------
Function<T,R>
IntFunction<R>
LongFunction<R>
DoubleFunction<R>
BiFunction<T,U,R>
Supplier<T>
P
a
r
a
m
T
int
long
double
T,U
void
Return Type
int
--------------------
ToIntFunction<T>
IntUnaryOperator
LongToIntFunction
DoubleToIntFunction
ToIntBiFunction<T,U>
IntSupplier
P
a
r
a
m
T
int
long
double
T,U
void
Return Type
long
---------------------
ToLongFunction<T>
IntToLongFunction
LongUnaryOperator
DoubleToLongFunction
ToLongBiFunction<T,U>
LongSupplier
P
a
r
a
m
T
int
long
double
T,U
void
Return Type
double
-----------------------
ToDoubleFunction<T>
IntToDoubleFunction
LongToDoubleFunction
DoubleUnaryOperator
ToDoubleBiFunction<T,U>
DoubleSupplier
P
a
r
a
m
T
int
long
double
T,U
void
Return Type
boolean
----------------
Predicate<T>
IntPredicate
LongPredicate
DoublePredicate
BiPredicate<T,U>
BooleanSupplier
P
a
r
a
m
T
int
long
double
T,U
void
Return Type
void
---------------
Consumer<T>
IntConsumer
LongConsumer
DoubleConsumer
BiConsumer<T,U>
-
于 2015-01-02T13:56:03.600 回答