Java8-Function

我们仔细看一下源码：

@FunctionalInterface
public interface Function<T, R> {
}

第一部分：接口声明，使用了@FunctionalInterface注解，此注解标注了Function接口为函数式接口（函数式接口就是只能有一个抽象方法），此注解跟@override类似，仅仅作为一个提示和编译检查的作用，也可以省略不写。

R apply(T t);

第二部分：接口中唯一的抽象方法apply，将function对象应用到输入的参数上，并且输出结果

default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }


default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

第三部分：compose方法和addThen方法，可以看到这2个方法内部的执行结构是一样的，仅仅执行顺序不同。

compose方法先执行输入参数的apply，再执行当前对象的apply。

addThen方法先执行当前对象的apply，再执行输入参数的apply。

举例说明：

public class TestFunction {
    public static void main(String[] args) {
        Function<Integer,Integer> function = t->t*2;
        Function<Integer,Integer> function1 = t->t*t;
        int value = function.andThen(function).apply(4);
        int value1 = function1.compose(function1).apply(4);
        int value2 = function.andThen(function1).apply(4);
        int value3 = function1.compose(function).apply(4);
        int value4 = function.compose(function).apply(4);
        int value5 = function.compose(function1).apply(4);
        int value6 = function1.andThen(function).apply(4);
        int value7 = function1.andThen(function1).apply(4);
        System.out.println("value = : "+value);
        System.out.println("value1 = : "+value1);
        System.out.println("value2 = : "+value2);
        System.out.println("value3 = : "+value3);
        System.out.println("value4 = : "+value4);
        System.out.println("value5 = : "+value5);
        System.out.println("value6 = : "+value6);
        System.out.println("value7 = : "+value7);
    }
}

运行结果：

value = : 16
value1 = : 256
value2 = : 64
value3 = : 64
value4 = : 16
value5 = : 32
value6 = : 32
value7 = : 256

对于value2的值，计算步骤是先计算4*2=8，再计算8*8=64.

而对于value5的值，先计算4*4=16，再计算16*2=32.其他的值以此类推。

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

第四部分：identity，返回一个总是返回其输入参数的方法

 

对于函数式接口，有如下示例：

public interface AddOK<T,S> {
    public S addOK(T t);
}

接下来：

        AddOK<Integer,String> addOK = t->t+"OK";
        String ss = addOK.addOK(888);
        System.out.println(ss);

结果：

888OK

可以简单理解为：t->t+"OK" 是 重写addOK的方法体，不必像以前那样需要写一个类实现接口，然后在类中重写addOK方法，代码变得十分简单。