第二章 JDK8新特性2之四大函数接口

Posted 2021-02-10 tangkongkong

　　在使用lambda表达式和自定义函数接口后，基本已实现java的函数式编程。但是一个自定义函数接口只做一件事，我们在使用的时候只关心需要输入什么参数、用这些参数来做什么，以及返回什么结果；至于接口名称，接口里的函数名称是阿猫阿狗，并不用care。所以直接用一个统一的接口来代替自定义接口，就不用自定义接口了。

2.1 jkd8函数接口Function

Function的使用很简单，只要把上篇的自定义接口改成Function，初体验：

 1 public class LambdaTester {
 2     public static void main(String[] args) {
 3         System.out.println("main function...");
 4         testFunction();
 5     }
 6 
 7 //以函数式接口作为参数
 8 //接口Function<T,R>，接收两个范型，T为参数类型，R为返回值类型
 9     private String operate2(Integer x, Function<Integer,String> foperation){
10         return foperation.apply(x);
11     }
12 
13     //测试函数接口，用两种方法实现Integer转String
14     public static void testFunction() {
15         LambdaTester tester = new LambdaTester();
16         
17         System.out.println("Integer转String 1：" + tester.operate2(6,x -> x.toString()));
18         System.out.println("Integer转String 2：" + tester.operate2(8,x -> x + ""));
19        
20     }
21 }

输出：

main function...
Integer转String的方法1：6
Integer转String的方法2：8

Function中定义了四个方法，摘出来瞧瞧：

 1 @FunctionalInterface
 2 public interface Function<T, R> {
 3 
 4     R apply(T t); //输入T，经apply执行后返回R
 5 
 6     default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
 7         Objects.requireNonNull(before);
 8         return (V v) -> apply(before.apply(v));
 9     }
10 
11     default <V> Function<T, V> andThen(Function<? super R, ? extends V> after){
12         Objects.requireNonNull(after);
13         return (T t) -> after.apply(apply(t));
14     }
15 
16     static <T> Function<T, T> identity() {
17         return t -> t;
18     }
19 }

 

2.1.1 andThen和compose详解

　　Function中的两个default函数andThen和compose，乍一看不知道干嘛的，都是接收一个Function返回一个Function，函数定义也类似。这种函数的强大之处是可以链式调用，先看andThen的例子：

 1 public class LambdaTester {
 2     public static void main(String[] args) {
 3         System.out.println("main function...");
 4 //        testLambda();
 5 //        testFunction();
 6 //        testDefault();
 7         testAndThen();
 8     }
 9 
10 //以函数式接口作为参数
11     private String operate3(String x, Function<String,String> foperation){
12         return foperation.apply(x);
13     }
14 
15 public static void testAndThen(){
16         LambdaTester tester = new LambdaTester();
17         //函数接口的链式调用
18         Function<String,String> function = x -> x + "world,";
19 
20         //andThen()
21         // @param: Function<? super R, ? extends V> after：接收参数为Function，Function操作的参数是上一个Function执行的结果
22         // @return: <V> Function<T, V>: 返回一个Function
23         System.out.println("结果为：" + tester.operate3("Hello ",
24                 function.andThen(s -> s + "I’m java8,")
25                         .andThen(s -> s + "enjoy my new feature!")));
26     }
27 }

输出：

main function...
结果为：Hello world,I’m java8,enjoy my new feature!

来分析下代码执行过程：

　　第一步：执行operate3，完成字符串拼接，得到结果Hello world,

　　第二步：将上一步得到的结果Hello world作为andThen()的参数s，执行lambda表达式，得到结果Hello world,I‘m java8,

　　第三步：将上一步得到的结果Hello world,I‘m java8,  执行lambda表达式，得到结果Hello world,I‘m java8,enjoy my new feature!

这是一种典型的链式调用方法，接收上一步执行的结果，处理后返回一个可以进行链式调用的对象，一级一级处理下去。

 

其他函数接口和Function类似，可以自行查阅API文档。

只有输出没有输入的是提供者supplier，有输入有输出的是消费者consumer。