JAVA8 Function＜T,R＞和 BiFunction＜T,U,R＞接口

本文链接：https://blog.csdn.net/xjj1314/article/details/119593897

Function是一个函数接口，接受一个输入参数，返回一个结果，是JDK 1.8 新增加的函数式接口。

public interface Function<T, R> {

    /**
     * 将此函数应用于给定参数
     * 真正执行函数接口的方法
     */
    R apply(T t);

    /**
     * 函数链，before执行的结果做根函数为参数
     */
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    /**
     * 函数链，根函数执行结果做为after的参数
     */
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    /**
     * 返回一个参数做为返回值的函数
     */
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

看注释有些绕，还是看例子

//例1
public class FunctionDemo {
    public static void main(String[] args) {
        Function<Integer,Integer> root = (v) -> {
            System.out.println("root apply");
            return v + 1;// 12
        };
        Function<Integer,Integer> before = (v) -> {
            System.out.println("before apply");
            return v + 1;// 先得结果11，再传给root
        };

        System.out.println(root.compose(before).apply(10));
        // before apply
        // root apply
        // 12
    }
}

//例2
public class FunctionDemo {
    public static void main(String[] args) {
        Function<Integer,Integer> root = (v) -> {
            System.out.println("root apply");
            return v + 1;// 先得结果11，再传给after
        };
        Function<Integer,Integer> after = (v) -> {
            System.out.println("after apply");
            return v + 1;// 12
        };

        System.out.println(root.andThen(after).apply(10));
        // root apply
        // after apply
        // 12
    }
}

例1和例2虽然参数一样，结果一样，但是相对与根函数root执行的顺序一个在前，一个在后。

Function与Consumer接口都有andThen方法，两者的区别是对参数的使用方式不同。每Consumer使用的是同一个原始参数，Function的参数只会被根函数使用一次，之后的函数使用的是前一个函数的结果做为参数。

了解了Function，其他的也就一目了然了：

BiFunction<T,U,R>：代表了一个接受两个输入参数的方法，并且返回一个结果

DoubleFunction<R>：代表接受一个double值参数的方法，并且返回结果

DoubleToIntFunction：接受一个double类型输入，返回一个int类型结果。

DoubleToLongFunction：接受一个double类型输入，返回一个long类型结果

IntFunction<R>:接受一个int类型输入参数，返回一个结果。

IntToDoubleFunction：接受一个int类型输入，返回一个double类型结果。

IntToLongFunction：接受一个int类型输入，返回一个long类型结果。

LongFunction<R>：接受一个long类型输入参数，返回一个结果。

LongToDoubleFunction：接受一个long类型输入，返回一个double类型结果。