转载

【Java系列教程】一起爪哇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是一个函数式接口。

怎么理解，看几个例子。

比如：你声明一个接口：

@FunctionalInterface
public interface Func {
}

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

@FunctionalInterface
public interface Func {
    void run();
}

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

@FunctionalInterface
public interface Func {
    void run();
    void foo();
}

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

@FunctionalInterface
public interface Func {
    boolean equals(Object obj);
}

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

@FunctionalInterface
public interface Func {
    boolean equals(Object obj);
    void run();
}

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

@FunctionalInterface
public interface Func {
    Object clone();
    void run();
}

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

所以总结一句话就是：

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

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

一个普通接口NonFunc：

public interface NonFunc {
    void foo();
    void voo();
}

函数式接口Func：

@FunctionalInterface
public interface Func extends NonFunc {

    void run();

    default void foo() {
        // do something
    }

    default void voo() {
        // do something
    }
}

实现的测试类：

public class TestJ8FunctionalInterface implements Func {

    public static void main(String[] args) {
        Func func = new TestJ8FunctionalInterface();
        func.run();
        func.foo();
        func.voo();
    }

    @Override
    public void run() {
        System.out.println("run");
    }

    @Override
    public void foo() {
        System.out.println("foo");
    }

    @Override
    public void voo() {
        System.out.println("voo");
    }
}

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

public class TestJ8FunctionalInterface2 {

    public static void main(String[] args) {
        TestJ8FunctionalInterface2 testJ8FunctionalInterface2 = new TestJ8FunctionalInterface2();
        // lambda
        testJ8FunctionalInterface2.test(10, () -> System.out.println("A customed Func."));
        // method reference
        testJ8FunctionalInterface2.test(100, testJ8FunctionalInterface2::customedFunc);
    }

    public void customedFunc() {
        System.out.println("A customed method reference.");
    }

    public void test(int x, Func func) {
        System.out.println(x);
        func.run();
    }
}

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

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

interface X { int m(Iterable<String> arg); }
interface Y { int m(Iterable<String> arg); }
interface Z extends X, Y {}

interface X { int m(Iterable<String> arg); }
interface Y { int m(Iterable<String> arg); }
interface Z extends X, Y {}

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

比如下面的例子就不是函数式接口：

interface X { int m(Iterable<String> arg); }
interface Y { int m(Iterable<Integer> arg); }
interface Z extends X, Y {}

interface X { int m(Iterable<String> arg, Class c); }
interface Y { int m(Iterable arg, Class<?> c); }
interface Z extends X, Y {}

interface X<T> { void m(T arg); }
interface Y<T> { void m(T arg); }
interface Z<A, B> extends X<A>, Y<B> {}

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

Function

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

@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
...
}

函数意为将参数T传递给一个函数，返回R。即$R=Function(T)$

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

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

高阶函数

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

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

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

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

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

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

//binary function
        BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b;
        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。分别对应单元算子和二元算子。

算子的接口声明如下：

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {

    static <T> UnaryOperator<T> identity() {
        return t -> t;
    }

二元算子的声明：

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {
    /**
     * Returns a {@link BinaryOperator} which returns the lesser of two elements
     * according to the specified {@code Comparator}.
     *
     * @param <T> the type of the input arguments of the comparator
     * @param comparator a {@code Comparator} for comparing the two values
     * @return a {@code BinaryOperator} which returns the lesser of its operands,
     *         according to the supplied {@code Comparator}
     * @throws NullPointerException if the argument is null
     */
    public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
    }

    /**
     * Returns a {@link BinaryOperator} which returns the greater of two elements
     * according to the specified {@code Comparator}.
     *
     * @param <T> the type of the input arguments of the comparator
     * @param comparator a {@code Comparator} for comparing the two values
     * @return a {@code BinaryOperator} which returns the greater of its operands,
     *         according to the supplied {@code Comparator}
     * @throws NullPointerException if the argument is null
     */
    public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
    }
}

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

public class TestOperator {

    public static void main(String[] args) {
        UnaryOperator<Integer> add = x -> x + 1;
        System.out.println(add.apply(1));

        BinaryOperator<Integer> addxy = (x, y) -> x + y;
        System.out.println(addxy.apply(3, 5));

        BinaryOperator<Integer> min = BinaryOperator.minBy((o1, o2) -> o1 - o2);
        System.out.println(min.apply(100, 200));
        BinaryOperator<Integer> max = BinaryOperator.maxBy((o1, o2) -> o1 - o2);
        System.out.println(max.apply(100, 200));
    }
}

例子里补充一点的是，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型返回值的子集。

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
    ...
}

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

public class TestJ8Predicate {

    public static void main(String[] args) {
        TestJ8Predicate testJ8Predicate = new TestJ8Predicate();
        testJ8Predicate.printBigValue(10, val -> val > 5);
        testJ8Predicate.printBigValueAnd(10, val -> val > 5);
        testJ8Predicate.printBigValueAnd(6, val -> val > 5);

        //binary predicate
        BiPredicate<Integer, Long> biPredicate = (x, y) -> x > 9 && y < 100;
        System.out.println(biPredicate.test(100, 50L));
    }

    public void printBigValue(int value, Predicate<Integer> predicate) {
        if (predicate.test(value)) {
            System.out.println(value);
        }
    }

    public void printBigValueAnd(int value, Predicate<Integer> predicate) {
        if (predicate.and(v -> v < 8).test(value)) {
            System.out.println("value < 8 : " + value);
        } else {
            System.out.println("value should < 8 at least.");
        }
    }
}

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接口的特殊表达——接受一个泛型参数，不需要返回值的函数接口。

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
    ...
}

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

public class TestJ8Consumer {

    public static void main(String[] args) {
        Consumer<Integer> consumer = System.out::println;
        consumer.accept(100);

        //use function, you always need one return value.
        Function<Integer, Integer> function = x -> {
            System.out.println(x);
            return x;
        };
        function.apply(100);
    }

}

其他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的函数接口，其声明如下：

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

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

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

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

这保证supplier对象输出的一直是1。

如果是要利用构造函数的能力呢？就可以这样：

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

这样的输出可以看到，全部的对象都是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方法	-	-