[关闭]
@changedi 2017-01-06T11:32:24.000000Z 字数 11634 阅读 3985

一起爪哇Java 8(一)——函数式接口

Java


引言

目前由于系统已经全面切换为JDK8,所以有必要系统的了解一下Java8的一些新特性,以便后续在日常工作中可以使用一些高级特性来提高编程效率。

因为Java8引入了函数式接口,在java.util.function包含了几大类函数式接口声明。这里第一篇主要研究一下Function相关的接口。

FunctionalInterface注解

Java8的新引入,包含函数式的设计,接口都有@FunctionalInterface的注解。就像这个注解的注释说明一样,它注解在接口层面,且注解的接口要有且仅有一个抽象方法。具体就是说,注解在Inteface上,且interface里只能有一个抽象方法,可以有default方法。因为从语义上来讲,一个函数式接口需要通过一个逻辑上的方法表达一个单一函数。那理解这个单一就很重要了,单一不是说限制你一个interface里只有一个抽象方法,单是多个方法的其他方法需要是继承自Object的public方法,或者你要想绕过,就自己实现default。函数式接口自己本身一定是只有一个抽象方法。同时,如果是Object类的public方法,也是不允许的。官方的说明翻译如下:

如果一个接口I,I有一组抽象方法集合M,且这些方法都不是Object类的public签名方法,那么如果存在一个M中的方法m,满足:
- m的签名是所有M中方法签名的子签名。
- m对于M中的每个方法都是返回类型可替换的。
此时,接口I是一个函数式接口。

怎么理解,看几个例子。

比如:你声明一个接口:

  1. @FunctionalInterface
  2. public interface Func {
  3. }

这会编译错,编译器会告诉你no target method。而如果加一个方法:

  1. @FunctionalInterface
  2. public interface Func {
  3. void run();
  4. }

这就OK了,一个函数式接口声明好了。再加一个呢?

  1. @FunctionalInterface
  2. public interface Func {
  3. void run();
  4. void foo();
  5. }

不ok,明确说了只有一个抽象方法嘛。但是如果换一种函数签名:

  1. @FunctionalInterface
  2. public interface Func {
  3. boolean equals(Object obj);
  4. }

错误依旧,因为这个方法签名是Object类的public方法。而再改一下:

  1. @FunctionalInterface
  2. public interface Func {
  3. boolean equals(Object obj);
  4. void run();
  5. }

这就OK了。一个抽象方法,一个Object的public方法,相安无事。Object还有其他方法,clone方法试试会怎么样?

  1. @FunctionalInterface
  2. public interface Func {
  3. Object clone();
  4. void run();
  5. }

这又不行了,因为前面明确说了,要是Object的public方法,而clone是protected的。

所以总结一句话就是:

函数式接口,有且仅有一个抽象方法,Object的public方法除外。

因为Java本身支持多接口实现,你定义一个Class可以implements多个interface。所以这个限制也没什么影响,如果想约定一个函数式接口来统一,也可以做一些默认的实现来达到一个接口多个抽象方法的目的,比如下面这种做法:
一个普通接口NonFunc:

  1. public interface NonFunc {
  2. void foo();
  3. void voo();
  4. }

函数式接口Func:

  1. @FunctionalInterface
  2. public interface Func extends NonFunc {
  3. void run();
  4. default void foo() {
  5. // do something
  6. }
  7. default void voo() {
  8. // do something
  9. }
  10. }

实现的测试类:

  1. public class TestJ8FunctionalInterface implements Func {
  2. public static void main(String[] args) {
  3. Func func = new TestJ8FunctionalInterface();
  4. func.run();
  5. func.foo();
  6. func.voo();
  7. }
  8. @Override
  9. public void run() {
  10. System.out.println("run");
  11. }
  12. @Override
  13. public void foo() {
  14. System.out.println("foo");
  15. }
  16. @Override
  17. public void voo() {
  18. System.out.println("voo");
  19. }
  20. }

函数式接口的一大特性就是可以被lambda表达式和函数引用表达式代替。也就是说声明这样的接口,是可以灵活的以方法来传参。看个例子:

  1. public class TestJ8FunctionalInterface2 {
  2. public static void main(String[] args) {
  3. TestJ8FunctionalInterface2 testJ8FunctionalInterface2 = new TestJ8FunctionalInterface2();
  4. // lambda
  5. testJ8FunctionalInterface2.test(10, () -> System.out.println("A customed Func."));
  6. // method reference
  7. testJ8FunctionalInterface2.test(100, testJ8FunctionalInterface2::customedFunc);
  8. }
  9. public void customedFunc() {
  10. System.out.println("A customed method reference.");
  11. }
  12. public void test(int x, Func func) {
  13. System.out.println(x);
  14. func.run();
  15. }
  16. }

上面例子列举了一个lambda模式和一个方法引用模式,这样就可以利用函数式编程强大的能力,将方法作为参数了。

另一个大的话题是针对上文的逻辑上的方法。所谓逻辑上,就是说当你出现函数式接口多重继承其他接口时,如果继承的多个接口有相同的方法签名,那么也是OK的。而这种相同签名的方法,也包括了泛型的情况,以下的声明中的Z接口,都是函数式接口。

  1. interface X { int m(Iterable<String> arg); }
  2. interface Y { int m(Iterable<String> arg); }
  3. interface Z extends X, Y {}
  4. interface X { int m(Iterable<String> arg); }
  5. interface Y { int m(Iterable<String> arg); }
  6. interface Z extends X, Y {}

但是要注意的是,这种泛型的支持,是因为函数式接口的官方声明规范里要求类型可替换和子签名,不是因为泛型擦除。
比如下面的例子就不是函数式接口:

  1. interface X { int m(Iterable<String> arg); }
  2. interface Y { int m(Iterable<Integer> arg); }
  3. interface Z extends X, Y {}
  4. interface X { int m(Iterable<String> arg, Class c); }
  5. interface Y { int m(Iterable arg, Class<?> c); }
  6. interface Z extends X, Y {}
  7. interface X<T> { void m(T arg); }
  8. interface Y<T> { void m(T arg); }
  9. interface Z<A, B> extends X<A>, Y<B> {}

最后,Java8里关于函数式接口的包是java.util.function,里面全部是函数式接口。主要包含几大类:Function、Predicate、Supplier、Consumer和*Operator(没有Operator接口,只有类似BinaryOperator这样的接口)。后面依次展开详细说明一下。

Function

关于Function接口,其接口声明是一个函数式接口,其抽象表达函数为

  1. @FunctionalInterface
  2. public interface Function<T, R> {
  3. R apply(T t);
  4. ...
  5. }

函数意为将参数T传递给一个函数,返回R。即

其默认实现了3个default方法,分别是compose、andThen和identity,对应的函数表达为:compose对应,体现嵌套关系;andThen对应,转换了嵌套的顺序;还有identity对应了一个传递自身的函数调用对应。从这里看出来,compose和andThen对于两个函数f和g来说,f.compose(g)等价于g.andThen(f)。看个例子:

  1. public class TestFunction {
  2. public static void main(String[] args) {
  3. Function<Integer, Integer> incr1 = x -> x + 1;
  4. Function<Integer, Integer> multiply = x -> x * 2;
  5. int x = 2;
  6. System.out.println("f(x)=x+1,when x=" + x + ", f(x)=" + incr1.apply(x));
  7. System.out.println("f(x)=x+1,g(x)=2x, when x=" + x + ", f(g(x))=" + incr1.compose(multiply).apply(x));
  8. System.out.println("f(x)=x+1,g(x)=2x, when x=" + x + ", g(f(x))=" + incr1.andThen(multiply).apply(x));
  9. System.out.println("compose vs andThen:f(g(x))=" + incr1.compose(multiply).apply(x) + "," + multiply.andThen(incr1).apply(x));
  10. }
  11. }

高阶函数

只是普通的lambda表达式,其能力有限。我们会希望引入更强大的函数能力——高阶函数,可以定义任意同类计算的函数。

  1. Function<Integer, Function<Integer, Integer>> makeAdder = z -> y -> z + y;

比如这个函数定义,参数是z,返回值是一个Function,这个Function本身又接受另一个参数y,返回z+y。于是我们可以根据这个函数,定义任意加法函数:

  1. //high order function
  2. Function<Integer, Function<Integer, Integer>> makeAdder = z -> y -> z + y;
  3. x = 2;
  4. //define add1
  5. Function<Integer, Integer> add1 = makeAdder.apply(1);
  6. System.out.println("f(x)=x+1,when x=" + x + ", f(x)=" + add1.apply(x));
  7. //define add5
  8. Function<Integer, Integer> add5 = makeAdder.apply(5);
  9. System.out.println("f(x)=x+5,when x=" + x + ", f(x)=" + add5.apply(x));

由于高阶函数接受一个函数作为参数,结果返回另一个函数,所以是典型的函数到函数的映射。

BiFunction提供了二元函数的一个接口声明,举例来说:

  1. //binary function
  2. BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b;
  3. System.out.println("f(z)=x*y, when x=3,y=5, then f(z)=" + multiply.apply(3, 5));

其输出结果将是:f(z)=x*y, when x=3,y=5, then f(z)=15
二元函数没有compose能力,只是默认实现了andThen。

有了一元和二元函数,那么可以通过组合扩展出更多的函数可能。

Function接口相关的接口包括:
- BiFunction :R apply(T t, U u);接受两个参数,返回一个值,代表一个二元函数;
- DoubleFunction :R apply(double value);只处理double类型的一元函数;
- IntFunction :R apply(int value);只处理int参数的一元函数;
- LongFunction :R apply(long value);只处理long参数的一元函数;
- ToDoubleFunction:double applyAsDouble(T value);返回double的一元函数;
- ToDoubleBiFunction:double applyAsDouble(T t, U u);返回double的二元函数;
- ToIntFunction:int applyAsInt(T value);返回int的一元函数;
- ToIntBiFunction:int applyAsInt(T t, U u);返回int的二元函数;
- ToLongFunction:long applyAsLong(T value);返回long的一元函数;
- ToLongBiFunction:long applyAsLong(T t, U u);返回long的二元函数;
- DoubleToIntFunction:int applyAsInt(double value);接受double返回int的一元函数;
- DoubleToLongFunction:long applyAsLong(double value);接受double返回long的一元函数;
- IntToDoubleFunction:double applyAsDouble(int value);接受int返回double的一元函数;
- IntToLongFunction:long applyAsLong(int value);接受int返回long的一元函数;
- LongToDoubleFunction:double applyAsDouble(long value);接受long返回double的一元函数;
- LongToIntFunction:int applyAsInt(long value);接受long返回int的一元函数;

Operator

Operator其实就是Function,函数有时候也叫作算子。算子在Java8中接口描述更像是函数的补充,和上面的很多类型映射型函数类似。

算子Operator包括:UnaryOperator和BinaryOperator。分别对应单元算子和二元算子。
算子的接口声明如下:

  1. @FunctionalInterface
  2. public interface UnaryOperator<T> extends Function<T, T> {
  3. static <T> UnaryOperator<T> identity() {
  4. return t -> t;
  5. }

二元算子的声明:

  1. @FunctionalInterface
  2. public interface BinaryOperator<T> extends BiFunction<T,T,T> {
  3. /**
  4. * Returns a {@link BinaryOperator} which returns the lesser of two elements
  5. * according to the specified {@code Comparator}.
  6. *
  7. * @param <T> the type of the input arguments of the comparator
  8. * @param comparator a {@code Comparator} for comparing the two values
  9. * @return a {@code BinaryOperator} which returns the lesser of its operands,
  10. * according to the supplied {@code Comparator}
  11. * @throws NullPointerException if the argument is null
  12. */
  13. public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
  14. Objects.requireNonNull(comparator);
  15. return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
  16. }
  17. /**
  18. * Returns a {@link BinaryOperator} which returns the greater of two elements
  19. * according to the specified {@code Comparator}.
  20. *
  21. * @param <T> the type of the input arguments of the comparator
  22. * @param comparator a {@code Comparator} for comparing the two values
  23. * @return a {@code BinaryOperator} which returns the greater of its operands,
  24. * according to the supplied {@code Comparator}
  25. * @throws NullPointerException if the argument is null
  26. */
  27. public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
  28. Objects.requireNonNull(comparator);
  29. return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
  30. }
  31. }

很明显,算子就是一个针对同类型输入输出的一个映射。在此接口下,只需声明一个泛型参数T即可。对应上面的例子:

  1. public class TestOperator {
  2. public static void main(String[] args) {
  3. UnaryOperator<Integer> add = x -> x + 1;
  4. System.out.println(add.apply(1));
  5. BinaryOperator<Integer> addxy = (x, y) -> x + y;
  6. System.out.println(addxy.apply(3, 5));
  7. BinaryOperator<Integer> min = BinaryOperator.minBy((o1, o2) -> o1 - o2);
  8. System.out.println(min.apply(100, 200));
  9. BinaryOperator<Integer> max = BinaryOperator.maxBy((o1, o2) -> o1 - o2);
  10. System.out.println(max.apply(100, 200));
  11. }
  12. }

例子里补充一点的是,BinaryOperator提供了两个默认的static快捷实现,帮助实现二元函数min(x,y)和max(x,y),使用时注意的是排序器可别传反了:)

其他的Operator接口:(不解释了)
- LongUnaryOperator:long applyAsLong(long operand);
- IntUnaryOperator:int applyAsInt(int operand);
- DoubleUnaryOperator:double applyAsDouble(double operand);
- DoubleBinaryOperator:double applyAsDouble(double left, double right);
- IntBinaryOperator:int applyAsInt(int left, int right);
- LongBinaryOperator:long applyAsLong(long left, long right);

Predicate

predicate是一个谓词函数,主要作为一个谓词演算推导真假值存在,其意义在于帮助开发一些返回bool值的Function。本质上也是一个单元函数接口,其抽象方法test接受一个泛型参数T,返回一个boolean值。等价于一个Function的boolean型返回值的子集。

  1. @FunctionalInterface
  2. public interface Predicate<T> {
  3. boolean test(T t);
  4. ...
  5. }

其默认方法也封装了and、or和negate逻辑。写个小例子看看:

  1. public class TestJ8Predicate {
  2. public static void main(String[] args) {
  3. TestJ8Predicate testJ8Predicate = new TestJ8Predicate();
  4. testJ8Predicate.printBigValue(10, val -> val > 5);
  5. testJ8Predicate.printBigValueAnd(10, val -> val > 5);
  6. testJ8Predicate.printBigValueAnd(6, val -> val > 5);
  7. //binary predicate
  8. BiPredicate<Integer, Long> biPredicate = (x, y) -> x > 9 && y < 100;
  9. System.out.println(biPredicate.test(100, 50L));
  10. }
  11. public void printBigValue(int value, Predicate<Integer> predicate) {
  12. if (predicate.test(value)) {
  13. System.out.println(value);
  14. }
  15. }
  16. public void printBigValueAnd(int value, Predicate<Integer> predicate) {
  17. if (predicate.and(v -> v < 8).test(value)) {
  18. System.out.println("value < 8 : " + value);
  19. } else {
  20. System.out.println("value should < 8 at least.");
  21. }
  22. }
  23. }

Predicate在Stream中有应用,Stream的filter方法就是接受Predicate作为入参的。这个具体在后面使用Stream的时候再分析深入。

其他Predicate接口:
- BiPredicate:boolean test(T t, U u);接受两个参数的二元谓词
- DoublePredicate:boolean test(double value);入参为double的谓词函数
- IntPredicate:boolean test(int value);入参为int的谓词函数
- LongPredicate:boolean test(long value);入参为long的谓词函数

Consumer

看名字就可以想到,这像谓词函数接口一样,也是一个Function接口的特殊表达——接受一个泛型参数,不需要返回值的函数接口。

  1. @FunctionalInterface
  2. public interface Consumer<T> {
  3. void accept(T t);
  4. ...
  5. }

这个接口声明太重要了,对于一些纯粹consume型的函数,没有Consumer的定义真无法被Function家族的函数接口表达。因为Function一定需要一个泛型参数作为返回值类型(当然不排除你使用Function来定义,但是一直返回一个无用的值)。比如下面的例子,如果没有Consumer,类似的行为使用Function表达就一定需要一个返回值。

  1. public class TestJ8Consumer {
  2. public static void main(String[] args) {
  3. Consumer<Integer> consumer = System.out::println;
  4. consumer.accept(100);
  5. //use function, you always need one return value.
  6. Function<Integer, Integer> function = x -> {
  7. System.out.println(x);
  8. return x;
  9. };
  10. function.apply(100);
  11. }
  12. }

其他Consumer接口:
- BiConsumer:void accept(T t, U u);接受两个参数
- DoubleConsumer:void accept(double value);接受一个double参数
- IntConsumer:void accept(int value);接受一个int参数
- LongConsumer:void accept(long value);接受一个long参数
- ObjDoubleConsumer:void accept(T t, double value);接受一个泛型参数一个double参数
- ObjIntConsumer:void accept(T t, int value);接受一个泛型参数一个int参数
- ObjLongConsumer:void accept(T t, long value);接受一个泛型参数一个long参数

Supplier

最后说的是一个叫做Supplier的函数接口,其声明如下:

  1. @FunctionalInterface
  2. public interface Supplier<T> {
  3. T get();
  4. }

其简洁的声明,会让人以为不是函数。这个抽象方法的声明,同Consumer相反,是一个只声明了返回值,不需要参数的函数(这还叫函数?)。也就是说Supplier其实表达的不是从一个参数空间到结果空间的映射能力,而是表达一种生成能力,因为我们常见的场景中不止是要consume(Consumer)或者是简单的map(Function),还包括了new这个动作。而Supplier就表达了这种能力。

比如你要是返回一个常量,那可以使用类似的做法:

  1. Supplier<Integer> supplier = () -> 1;
  2. System.out.println(supplier.get());

这保证supplier对象输出的一直是1。
如果是要利用构造函数的能力呢?就可以这样:

  1. Supplier<TestJ8Supplier> anotherSupplier;
  2. for (int i = 0; i < 10; i++) {
  3. anotherSupplier = TestJ8Supplier::new;
  4. System.out.println(anotherSupplier.get());
  5. }

这样的输出可以看到,全部的对象都是new出来的。

这样的场景在Stream计算中会经常用到,具体在分析Java 8中Stream的时候再深入。

其他Supplier接口:
- BooleanSupplier:boolean getAsBoolean();返回boolean
- DoubleSupplier:double getAsDouble();返回double
- IntSupplier:int getAsInt();返回int
- LongSupplier:long getAsLong();返回long

总结

整个函数式接口的大概总结如下:

名称 一元接口 说明 二元接口 说明
一般函数 Function 一元函数,抽象apply方法 BiFunction 二元函数,抽象apply方法
算子函数(输入输出同类型) UnaryOperator 一元算子,抽象apply方法 BinaryOperator 二元算子,抽象apply方法
谓词函数(输出boolean) Predicate 一元谓词,抽象test方法 BiPredicate 二元谓词,抽象test方法
消费者(无返回值) Consumer 一元消费者函数,抽象accept方法 BiConsumer 二元消费者函数,抽象accept方法
供应者(无参数,只有返回值) Supplier 供应者函数,抽象get方法 - -
添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注