官方解释：

一个函数式接口，函数方法为 apply(Object);
接受一个参数，返回一个接口；

  1. @FunctionalInterface
  2. public interface Function<T, R> {
  4.     // 待实现的 函数式 接口
  5.     R apply(T t);
  7.     // 将两个函数式接口拼接在一起，第1个方法的结果作为 第二个方法的参数
  8.     default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
  9.         Objects.requireNonNull(before);
  10.         return (V v) -> apply(before.apply(v));
  11.     }
  13.     // 将两个函数式接口拼接在一起，第1个方法的结果作为 第二个方法的参数 【与上一个行为相反，参见下面case】
  14.     default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
  15.         Objects.requireNonNull(after);
  16.         return (T t) -> after.apply(apply(t));
  17.     }
  19.     static <T> Function<T, T> identity() {
  20.         return t -> t;
  21.     }
  22. }

案例

  1. /**
  2.  * function demo
  3.  */
  4. public class FunctionTest {
  6.     public static int compute(int a, Function<Integer, Integer> function) {
  7.         return function.apply(a);
  8.     }
  10.     public static int composeCompute(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {
  11.         return function1.compose(function2).apply(a);
  12.     }
  14.     public static int andThenCompute(int a,Function<Integer,Integer> function1,Function<Integer,Integer> function2){
  15.         return function1.andThen(function2).apply(a);
  16.     }
  18.     public static int biCompute(int a,int b, BiFunction<Integer,Integer,Integer> function){
  19.         return function.apply(a,b);
  20.     }
  22.     public static void main(String[] args) {
  23.         // int result = compute(1, value -> value + 1);
  25.         // int result = composeCompute(1,value -> value + 1,value -> value * 2);
  27.         // int result = andThenCompute(1,value -> value + 1,value -> value * 2);
  29.         int result = biCompute(1,2, Integer::sum);
  30.         System.out.println("------->  " + result);
  32.     }
  35. }