JDK中已有的一些接口本身就是函数式接口,如Runnable。 JDK 8中又增加了java.util.function包, 提供了常用的函数式接口。

JDK 8之前已有的函数式接口

  • java.lang.Runnable
  • java.util.concurrent.Callable
  • java.security.PrivilegedAction
  • java.util.Comparator
  • java.io.FileFilter
  • java.nio.file.PathMatcher
  • java.lang.reflect.InvocationHandler
  • java.beans.PropertyChangeListener
  • java.awt.event.ActionListener
  • javax.swing.event.ChangeListener

新定义的函数式接口

java.util.function中定义了几组类型的函数式接口以及针对基本数据类型的子接口。

  • Predicate – 传入一个参数,返回一个bool结果, 方法为boolean test(T t)
  • Consumer – 传入一个参数,无返回值,纯消费。 方法为void accept(T t)
  • Function – 传入一个参数,返回一个结果,方法为R apply(T t)
  • Supplier – 无参数传入,返回一个结果,方法为T get()
  • UnaryOperator – 一元操作符, 继承Function,传入参数的类型和返回类型相同。
  • BinaryOperator – 二元操作符, 传入的两个参数的类型和返回类型相同, 继承BiFunction

Predicate

1
2
3
4
5
6
7
8
9
10
// 只需注明传入参数的类型,返回值为Bool
Predicate<Integer> fun1 = (x) -> x > 1;
Boolean bool = fun1.test(2); // bool = true

// 可以使用大括号来包住一个代码块,不过需要使用return来确定最后的返回值
Predicate<Integer> fun11 = (x) -> {
Integer sum = x * 1000 + 1;
return sum > 2000;
};
Boolean bool1 = fun11.test(2); // bool1 = true

Predicate 扩展的函数列表

interface functional method 说明
Predicate boolean test(T t) 接收一个泛型参数
IntPredicate boolean test(int value) 以下三个接口,接收指定类型的参数
LongPredicate boolean test(long value)
DoublePredicate boolean test(double value)
BiPredicate<T,U> boolean test(T t, U u) 接收两个泛型参数,分别为T,U

Consumer

1
2
3
// 需注明传入参数的类型,无返回值
Consumer<String> fun2 = (x) -> System.out.println(x);
fun2.accept("hello world"); // hello world

Consumer 扩展的函数列表

接收一个参数

interface functional method 说明
Consumer void accept(T t) 接收一个泛型参数,无返回值
IntConsumer void accept(int value) 以下三个类,接收一个指定类型的参数
LongConsumer void accept(long value)
DoubleConsumer void accept(double value)

接收两个参数

interface functional method 说明
BiConsumer<T, U> void accept(T t, U u) 接收两个泛型参数
ObjIntConsumer void accept(T t, int value) 以下三个类,接收一个泛型参数,一个指定类型的参数
ObjLongConsumer void accept(T t, long value)
ObjDoubleConsumer void accept(T t, double value)

Function

1
2
Function<String, Integer> fun3 = (x) -> Integer.valueOf(x);
Integer num = fun3.apply("1024"); // num = 1024

接收单个参数

Interface functional method 说明
Function<T,R> R apply(T t) 接收参数类型为T,返回参数类型为R
IntFunction R apply(int value) 以下三个接口,指定了接收参数类型,返回参数类型为泛型R
LongFunction R apply(long value)
Double R apply(double value)
ToIntFunction int applyAsInt(T value) 以下三个接口,指定了返回参数类型,接收参数类型为泛型T
ToLongFunction long applyAsLong(T value)
ToDoubleFunction double applyAsDouble(T value)
IntToLongFunction long applyAsLong(int value) 以下六个接口,既指定了接收参数类型,也指定了返回参数类型
IntToDoubleFunction double applyAsLong(int value)
LongToIntFunction int applyAsLong(long value)
LongToDoubleFunction double applyAsLong(long value)
DoubleToIntFunction int applyAsLong(double value)
DoubleToLongFunction long applyAsLong(double value)
UnaryOperator T apply(T t) 特殊的Function,接收参数类型和返回参数类型一样
IntUnaryOperator int applyAsInt(int left, int right) 以下三个接口,制定了接收参数和返回参数类型,并且都一样
LongUnaryOperator long applyAsInt(long left, long right)
DoubleUnaryOperator double applyAsInt(double left, double right)

接收两个参数

interface functional method 说明
BiFunction<T, U, R> R apply(T t, U u) 接收两个参数的Function
ToIntBiFunction<T, U> int applyAsInt(T t, U u) 以下三个接口,指定了返回参数类型,接收参数类型分别为泛型T, U
ToLongBiFunction<T, U> long applyAsLong(T t, U u)
ToDoubleBiFunction<T,U> double appleyAsDouble(T t, U u)
BinaryOperator T apply(T t, T u) 特殊的BiFunction, 接收参数和返回参数类型一样
IntBinaryOperator int applyAsInt(int left, int right)
LongBinaryOperator long applyAsInt(long left, long right)
DoubleBinaryOperator double applyAsInt(double left, double right)

Supplier

1
2
3
// 无参数传入,需注明返回的参数类型
Supplier<String> fun4 = () -> "hello world";
String word = fun4.get(); // word = "hello world"

Supplier 扩展函数列表

interface functional method 说明
Supplier T get() 返回类型为泛型T
BooleanSupplier boolean getAsBoolean() 以下三个接口,返回指定类型
IntSupplier int getAsInt()
LongSupplier long getAsLong()
DoubleSupplier double getAsDouble()

UnaryOperator

一元操作符, 继承Function,传入参数的类型和返回类型相同。

1
2
3
// 注明参数的类型
UnaryOperator<String> fun5 = (x) -> "你好,欢迎" + x;
String word = fun5.apply("张三"); // word = "你好,欢迎张三"

BinaryOperator

二元操作符, 传入的两个参数的类型和返回类型相同, 继承 BiFunction

1
2
3
// 因为传入的两个参数和返回类型均一致,则只需注明一个类型就行了
BinaryOperator<String> fun6 = (x, y) -> x + y;
String word = fun6.apply("hello ", "java"); // word = "hello java"