在使用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。
原文地址：https://www.cnblogs.com/tangkongkong/p/10385020.html