1 Function<T, R>中的T, R表示接口输入、输出的数据类型。

• R apply(T t)
  public class FunctionTest {
  public static void main(String[] args) {
  FunctionTest functionTest = new FunctionTest();
  // return e + 5;就是apply方法的具体实现
  Function<Integer, Integer> func = e -> {return e + 5;};
  int result = functionTest.calculate(5, func);
  System.out.println(result);
  }

  //对单个参数进行抽象的处理，而具体的处理逻辑在调用时传入：即传递的是一种操作    
  public int calculate(Integer a, Function<Integer, Integer> function) {        
      return function.apply(a);    
  } 
  

• func是定义好的Function接口类型的变量，他的输入、输出都是Integer类型。

• 调用calculate方法时，将func作为参数传入，对参数5进行处理。

• 因此，Function接口抽象出了一种对单个参数进行处理的操作。而具体的处理逻辑在调用时传入：即传递的是一种操作。

• andThen

  • 先处理参数，再对返回值使用操作after进行处理。
    Function<Integer, Integer> func = e -> {return e + 5;};
    Function<Integer, Integer> func2 = e -> {return e * 5;};
    //func2即after
    func.andThen(func2).apply(5); // 50

• compose

  • 和andThen刚好相反：先使用操作before处理参数，再对返回值进行处理。
    Function<Integer, Integer> func = e -> {return e + 5;};
    Function<Integer, Integer> func2 = e -> {return e * 5;};
    //func2即before
    func.compose(func2).apply(5); // 30
  • compose源码
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
    Objects.requireNonNull(before);
    return (V v) -> apply(before.apply(v));//第一个apply是调用当前接口的方法
    }
  • 注意compose方法的返回值依然是Function<T, R>类型，所以不是
    return this.apply(before.apply(v));

• 扩展组合Function

      public class FunctionTest2 {    
            public static void main(String[] args) {        
                  FunctionTest2 functionTest2 =  new FunctionTest2(); 
                  int result1 = functionTest2.compute(5, e -> e * 5, e -> e + 5);        
                  int result2 = functionTest2.compute2(5, e -> e * 5, e -> e + 5);       
                  int result3 = functionTest2.compute3(5, e -> e * 5, e -> e + 5);        
                  int result4 = functionTest2.compute4(5, e -> e * 5, e -> e + 5);       
                  System.out.println(result1);//50  
                  System.out.println(result2);//30      
                  System.out.println(result3);//130   
                  System.out.println(result4);//250    
            }    
  
            public int compute(int source, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {        
                   return function1.compose(function2).apply(source);   
            }    
            public int compute2(int source, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {        
                   return function1.andThen(function2).apply(source);    
            }    
            public int compute3(int source, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {        
                  return function1.andThen(function2).compose(function1).apply(source); //从后往前    
            }    
            public int compute4(int source, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {        
                  return function1.compose(function2).andThen(function1).apply(source);    }
            }
  

2 BiFunction<T, U, R>中的T, U表示接口输入的第一、第二个参数、R是输出的数据类型。

 public class BIFunctionTest {    
       public static void main(String[] args) {        
              //定义BiFunction对象，并调用apply方法
              BiFunction<Integer, String, Integer> biFunction = (t, u) -> {
                                         return t + Integer.parseInt(u);
                                    };   
              System.out.println(biFunction.apply(5, "6")); //11   
              
              System.out.println("------------------------------------------");        
              
              //方法调用时，作为参数（操作）传入        
              BIFunctionTest biFunctionTest = new BIFunctionTest();      
              int result = biFunctionTest.compute(5, 6, (t, u) -> {return t + u;});        
              System.out.println(result); //11        
              
              //BiFunction与Function的组合       
              int result2 = biFunctionTest.compute2(5, 6, (t, u) -> {return t + u;}, t -> t * t);        
              System.out.println(result2); //121    
       }    

       public int compute(Integer a, Integer b, BiFunction<Integer, Integer, Integer> biFunction) {
              return biFunction.apply(a, b);    
       }    

       //BIFunction的返回作为Function的输入    
       public int compute2(Integer a, Integer b, BiFunction<Integer, Integer, Integer> biFunction, Function<Integer, Integer> function) {       
             return biFunction.andThen(function).apply(a, b);   
       }}

• 注意，BiFunction中没有compose默认函数。