概念
函数式接口在Java中是指:有且仅有一个抽象方法的接口。函数式接口,即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda,所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法,Java中的Lambda才能顺利地进行推导。
语法糖
是指使用更加方便,但是原理不变的代码语法。例如在遍历集合时使用的for-each语法,其实底层的实现原理仍然是迭代器,这便是“语法糖”。从应用层面来讲,Java中的Lambda可以被当做是匿名内部类的“语法糖”,但是二者在原理上是不同的。
函数式接口的定义
格式:
由于接口当中抽象方法的 public abstract 是可以省略的,所以定义一个函数式接口很简单:
public interface MyFunctionalInterface { void myMethod(); }
怎么样保证我们的定义的接口是函数式接口?Java 8中专门为函数式接口引入了一个新的注解: @FunctionalInterface 。该注解可用于一个接口的定义上:一旦使用该注解来定义接口,编译器将会强制检查该接口是否确实有且仅有一个抽象方法,否则将会报错。需要注意的是,即使不使用该注解,只要满足函数式接口的定义,这仍然是一个函数式接口,使用起来都一样。
@FunctionalInterface注解
package demo01; /* 函数式接口:有且只有一个抽象方法的接口,称之为函数式接口 当然接口中可以包含其他的方法(默认,静态,私有) @FunctionalInterface注解 作用:可以检测接口是否是一个函数式接口 是:编译成功 否:编译失败(接口中没有抽象方法抽象方法的个数多余1个) */ @FunctionalInterface public interface MyFunctionalInterface { //定义一个抽象方法 public abstract void method(); }
函数式接口的使用
- 典型使用场景就是作为方法的参数
自定义函数式接口
@FunctionalInterface public interface MyFunctionalInterface { //定义一个抽象方法 public abstract void method(); }
定义测试类
package demo01; /* 函数式接口的使用:一般可以作为方法的参数和返回值类型 */ public class Demo { //定义一个方法,参数使用函数式接口MyFunctionalInterface public static void show(MyFunctionalInterface myInter){ myInter.method(); } public static void main(String[] args) { // show(new MyFunctionalInterfaceImpl()); 调用show方法,方法的参数是一个接口,所以可以传递接口的实现类对象 //调用show方法,方法的参数是一个接口,所以我们可以传递接口的匿名内部类 show(new MyFunctionalInterface() { @Override public void method() { System.out.println("使用匿名内部类重写接口中的抽象方法"); } }); //调用show方法,方法的参数是一个函数式接口,所以我们可以Lambda表达式 show(()->{ System.out.println("使用Lambda表达式重写接口中的抽象方法"); }); //简化Lambda表达式 show(()-> System.out.println("使用Lambda表达式重写接口中的抽象方法")); } }
函数式编程
Lambda的延迟执行
有些场景的代码执行后,结果不一定会被使用,从而造成性能浪费。而Lambda表达式是延迟执行的,这正好可以作为解决方案,提升性能。
性能浪费的日志案例
注:日志可以帮助我们快速的定位问题,记录程序运行过程中的情况,以便项目的监控和优化。查看下面代码
package demo02; public class Demo01Logger { //定义一个根据日志的级别,显示日志信息的方法 public static void showLog(int level, String message) { //对日志的等级进行判断,如果是1级别,那么输出日志信息 if (level == 1) { System.out.println(message); } } public static void main(String[] args) { //定义三个日志信息 String msg1 = "Hello"; String msg2 = "World"; String msg3 = "Java"; //调用showLog方法,传递日志级别和日志信息 showLog(2, msg1 + msg2 + msg3); } }
这段代码存在问题:无论级别是否满足要求,作为 log 方法的第二个参数,三个字符串一定会首先被拼接并传入方法内,然后才会进行级别判断。如果级别不符合要求,那么字符串的拼接操作就白做了,存在性能浪费。我们可以使用lambda表达式去解决上述代码存在的性能浪费的问题。
使用Lambda的提前
- 必然需要一个函数式接口
定义一个函数式接口
package demo03; @FunctionalInterface public interface MessageBuilder { //定义一个拼接消息的抽象方法,返回被拼接的消息 public abstract String builderMessage(); }
使用函数式接口
package demo03; /* 使用Lambda优化日志案例 Lambda的特点:延迟加载 Lambda的使用前提,必须存在函数式接口 */ public class Demo02Lambda { //定义一个显示日志的方法,方法的参数传递日志的等级和MessageBuilder接口 public static void showLog(int level, MessageBuilder mb) { //对日志的等级进行判断,如果是1级,则调用MessageBuilder接口中的builderMessage方法 if (level == 1) { System.out.println(mb.builderMessage()); } } public static void main(String[] args) { //定义三个日志信息 String msg1 = "Hello"; String msg2 = "World"; String msg3 = "Java"; /* 使用Lambda表达式作为参数传递,仅仅是把参数传递到showLog方法中 只有满足条件,日志的等级是1级 才会调用接口MessageBuilder中的方法builderMessage 才会进行字符串的拼接 如果条件不满足,日志的等级不是1级 那么MessageBuilder接口中的方法builderMessage也不会执行 所以拼接字符串的代码也不会执行 所以不会存在性能的浪费 */ //调用showLog方法,参数MessageBuilder是一个函数式接口,所以可以传递Lambda表达式 showLog(2, () -> { System.out.println("不满足条件不执行"); //返回一个拼接好的字符串 return msg1 + msg2 + msg3; }); } }
使用Lambda作为参数和返回值
- 作为参数
如果抛开实现原理不说,Java中的Lambda表达式可以被当作是匿名内部类的替代品。如果方法的参数是一个函数式接口类型,那么就可以使用Lambda表达式进行替代。使用Lambda表达式作为方法参数,其实就是使用函数式接口作为方法参数。例如 java.lang.Runnable 接口就是一个函数式接口,假设有一个 startThread 方法使用该接口作为参数,那么就可以使用Lambda进行传参。这种情况其实和 Thread 类的构造方法参数为 Runnable 没有本质区别。
package demo04; /* 例如java.lang.Runnable接口就是一个函数式接口, 假设有一个startThread方法使用该接口作为参数,那么就可以使用Lambda进行传参。 这种情况其实和Thread类的构造方法参数为Runnable没有本质区别。 */ public class Demo01Runnable { //定义一个方法startThread,方法的参数使用函数式接口Runnable public static void startThread(Runnable run) { //开启多线程 new Thread(run).start(); } public static void main(String[] args) { //调用startThread方法,方法的参数是一个接口,那么我们可以传递这个接口的匿名内部类 startThread(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName() + "-->" + "线程启动了"); } }); //调用startThread方法,方法的参数是一个函数式接口,所以可以传递Lambda表达式 startThread(() -> { System.out.println(Thread.currentThread().getName() + "-->" + "线程启动了"); }); //优化Lambda表达式 startThread(() -> System.out.println(Thread.currentThread().getName() + "-->" + "线程启动了")); } }
类似地,如果一个方法的返回值类型是一个函数式接口,那么就可以直接返回一个Lambda表达式。当需要通过一个方法来获取一个 java.util.Comparator 接口类型的对象作为排序器时,就可以调该方法获取。
package demo04; import java.util.Arrays; import java.util.Comparator; /* 如果一个方法的返回值类型是一个函数式接口,那么就可以直接返回一个Lambda表达式。 当需要通过一个方法来获取一个java.util.Comparator接口类型的对象作为排序器时,就可以调该方法获取。 */ public class Demo02Comparator { //定义一个方法,方法的返回值类型使用函数式接口Comparator public static Comparator<String> getComparator() { //方法的返回值类型是一个接口,那么我们可以返回这个接口的匿名内部类 /*return new Comparator<String>() { @Override public int compare(String o1, String o2) { //按照字符串的降序排序 return o2.length()-o1.length(); } };*/ //方法的返回值类型是一个函数式接口,所有我们可以返回一个Lambda表达式 /*return (String o1, String o2)->{ //按照字符串的降序排序 return o2.length()-o1.length(); };*/ //继续优化Lambda表达式 return (o1, o2) -> o2.length() - o1.length(); } public static void main(String[] args) { //创建一个字符串数组 String[] arr = {"aaa", "b", "cccccc", "dddddddddddd"}; //输出排序前的数组 System.out.println(Arrays.toString(arr));//[aaa, b, cccccc, dddddddddddd] //调用Arrays中的sort方法,对字符串数组进行排序 Arrays.sort(arr, getComparator()); //输出排序后的数组 System.out.println(Arrays.toString(arr));//[dddddddddddd, cccccc, aaa, b] } }
常用函数式接口
JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景,它们主要在 java.util.function 包中被提供。下面是最简单的几个接口及使用示例。
Supplier接口
java.util.function.Supplier<T> 接口仅包含一个无参的方法: T get() 。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口,这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。
基本使用
package demo04; import java.util.function.Supplier; /* 常用的函数式接口 java.util.function.Supplier<T>接口仅包含一个无参的方法:T get()。用来获取一个泛型参数指定类型的对象数据。 Supplier<T>接口被称之为生产型接口,指定接口的泛型是什么类型,那么接口中的get方法就会生产什么类型的数据 */ public class Demo01Supplier { //定义一个方法,方法的参数传递Supplier<T>接口,泛型执行String,get方法就会返回一个String public static String getString(Supplier<String> sup) { return sup.get(); } public static void main(String[] args) { //调用getString方法,方法的参数Supplier是一个函数式接口,所以可以传递Lambda表达式 String s = getString(() -> { //生产一个字符串,并返回 return "加油"; }); System.out.println(s); //优化Lambda表达式 String s2 = getString(() -> "加油"); System.out.println(s2); } }
题目
使用 Supplier 接口作为方法参数类型,通过Lambda表达式求出int数组中的最大值。提示:接口的泛型请使用java.lang.Integer 类。
代码实现
package demo04; import java.util.function.Supplier; public class Demo02Test { //定义一个方法,用于获取int类型数组中元素的最大值,方法的参数传递Supplier接口,泛型使用Integer public static int getMax(Supplier<Integer> sup) { return sup.get(); } public static void main(String[] args) { //定义一个int类型的数组,并赋值 int[] arr = {100, 0, -50, 880, 99, 33, -30}; //调用getMax方法,方法的参数Supplier是一个函数式接口,所以可以传递Lambda表达式 int maxValue = getMax(() -> { //获取数组的最大值,并返回 //定义一个变量,把数组中的第一个元素赋值给该变量,记录数组中元素的最大值 int max = arr[0]; //遍历数组,获取数组中的其他元素 for (int i : arr) { //使用其他的元素和最大值比较 if (i > max) { //如果i大于max,则替换max作为最大值 max = i; } } //返回最大值 return max; }); System.out.println("数组中元素的最大值是:" + maxValue);//数组中元素的最大值是:880 } }
Consumer接口
java.util.function.Consumer<T> 接口则正好与Supplier接口相反,它不是生产一个数据,而是消费一个数据,其数据类型由泛型决定。Consumer 接口中包含抽象方法 void accept(T t) ,意为消费一个指定泛型的数据。
基本使用
package demo04; import java.util.function.Consumer; /* java.util.function.Consumer<T>接口则正好与Supplier接口相反, 它不是生产一个数据,而是消费一个数据,其数据类型由泛型决定。 Consumer接口中包含抽象方法void accept(T t),意为消费一个指定泛型的数据。 Consumer接口是一个消费型接口,泛型执行什么类型,就可以使用accept方法消费什么类型的数据 至于具体怎么消费(使用),需要自定义(输出,计算....) */ public class Demo01Consumer { /* 定义一个方法 方法的参数传递一个字符串的姓名 方法的参数传递Consumer接口,泛型使用String 可以使用Consumer接口消费字符串的姓名 */ public static void method(String name, Consumer<String> con){ con.accept(name); } public static void main(String[] args) { //调用method方法,传递字符串姓名,方法的另一个参数是Consumer接口,是一个函数式接口,所以可以传递Lambda表达式 method("赵丽颖",(String name)->{ //对传递的字符串进行消费 //消费方式:直接输出字符串 //System.out.println(name); //消费方式:把字符串进行反转输出 String reName = new StringBuffer(name).reverse().toString(); System.out.println(reName);//颖丽赵 }); } }
默认方法:andThen
如果一个方法的参数和返回值全都是 Consumer 类型,那么就可以实现效果:消费数据的时候,首先做一个操作,然后再做一个操作,实现组合。而这个方法就是 Consumer 接口中的default方法 andThen 。要想实现组合,需要两个或多个Lambda表达式即可,而 andThen 的语义正是“一步接一步”操作。例如
package demo04; import java.util.function.Consumer; /* Consumer接口的默认方法andThen 作用:需要两个Consumer接口,可以把两个Consumer接口组合到一起,在对数据进行消费 例如: Consumer<String> con1 Consumer<String> con2 String s = "hello"; con1.accept(s); con2.accept(s); 连接两个Consumer接口 再进行消费 con1.andThen(con2).accept(s); 谁写前边谁先消费 */ public class Demo02AndThen { //定义一个方法,方法的参数传递一个字符串和两个Consumer接口,Consumer接口的泛型使用字符串 public static void method(String s, Consumer<String> con1, Consumer<String> con2) { //con1.accept(s); //con2.accept(s); //使用andThen方法,把两个Consumer接口连接到一起,在消费数据 con1.andThen(con2).accept(s);//con1连接con2,先执行con1消费数据,在执行con2消费数据 } public static void main(String[] args) { //调用method方法,传递一个字符串,两个Lambda表达式 method("Hello", (t) -> { //消费方式:把字符串转换为大写输出 System.out.println(t.toUpperCase()); }, (t) -> { //消费方式:把字符串转换为小写输出 System.out.println(t.toLowerCase()); }); } }
Predicate接口
有时候我们需要对某种类型的数据进行判断,从而得到一个boolean值结果。这时可以使用java.util.function.Predicate<T> 接口。Predicate 接口中包含一个抽象方法: boolean test(T t) 。用于条件判断的场景。
基本使用
package demo05; import java.util.function.Predicate; /* java.util.function.Predicate<T>接口 作用:对某种数据类型的数据进行判断,结果返回一个boolean值 Predicate接口中包含一个抽象方法: boolean test(T t):用来对指定数据类型数据进行判断的方法 结果: 符合条件,返回true 不符合条件,返回false */ public class Demo01Predicate { /* 定义一个方法 参数传递一个String类型的字符串 传递一个Predicate接口,泛型使用String 使用Predicate中的方法test对字符串进行判断,并把判断的结果返回 */ public static boolean checkString(String s, Predicate<String> pre) { return pre.test(s); } public static void main(String[] args) { //定义一个字符串 String s = "abcdef"; //调用checkString方法对字符串进行校验,参数传递字符串和Lambda表达式 /*boolean b = checkString(s,(String str)->{ //对参数传递的字符串进行判断,判断字符串的长度是否大于5,并把判断的结果返回 return str.length()>5; });*/ //优化Lambda表达式 boolean b = checkString(s, str -> str.length() > 5); System.out.println(b); } }
默认方法:and
既然是条件判断,就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实现“并且”的效果时,可以使用default方法 and 。
基本使用
package com.itheima.demo06.Predicate; import java.util.function.Predicate; /* 逻辑表达式:可以连接多个判断的条件 &&:与运算符,有false则false ||:或运算符,有true则true !:非(取反)运算符,非真则假,非假则真 需求:判断一个字符串,有两个判断的条件 1.判断字符串的长度是否大于5 2.判断字符串中是否包含a 两个条件必须同时满足,我们就可以使用&&运算符连接两个条件 Predicate接口中有一个方法and,表示并且关系,也可以用于连接两个判断条件 default Predicate<T> and(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> this.test(t) && other.test(t); } 方法内部的两个判断条件,也是使用&&运算符连接起来的 */ public class Demo02Predicate_and { /* 定义一个方法,方法的参数,传递一个字符串 传递两个Predicate接口 一个用于判断字符串的长度是否大于5 一个用于判断字符串中是否包含a 两个条件必须同时满足 */ public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) { //return pre1.test(s) && pre2.test(s); return pre1.and(pre2).test(s);//等价于return pre1.test(s) && pre2.test(s); } public static void main(String[] args) { //定义一个字符串 String s = "abcdef"; //调用checkString方法,参数传递字符串和两个Lambda表达式 boolean b = checkString(s, (String str) -> { //判断字符串的长度是否大于5 return str.length() > 5; }, (String str) -> { //判断字符串中是否包含a return str.contains("a"); }); System.out.println(b); } }
默认方法:or
与 and 的“与”类似,默认方法 or 实现逻辑关系中的“或”。
基本使用
package demo05; import java.util.function.Predicate; /* 需求:判断一个字符串,有两个判断的条件 1.判断字符串的长度是否大于5 2.判断字符串中是否包含a 满足一个条件即可,我们就可以使用||运算符连接两个条件 Predicate接口中有一个方法or,表示或者关系,也可以用于连接两个判断条件 default Predicate<T> or(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) || other.test(t); } 方法内部的两个判断条件,也是使用||运算符连接起来的 */ public class Demo03Predicate_or { /* 定义一个方法,方法的参数,传递一个字符串 传递两个Predicate接口 一个用于判断字符串的长度是否大于5 一个用于判断字符串中是否包含a 满足一个条件即可 */ public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) { //return pre1.test(s) || pre2.test(s); return pre1.or(pre2).test(s);//等价于return pre1.test(s) || pre2.test(s); } public static void main(String[] args) { //定义一个字符串 String s = "bc"; //调用checkString方法,参数传递字符串和两个Lambda表达式 boolean b = checkString(s, (String str) -> { //判断字符串的长度是否大于5 return str.length() > 5; }, (String str) -> { //判断字符串中是否包含a return str.contains("a"); }); System.out.println(b); } }
默认方法:negate
“与”、“或”已经了解了,剩下的“非”(取反)也会简单。从实现中很容易看出,它是执行了test方法之后,对结果boolean值进行“!”取反而已。一定要在 test 方法调用之前调用 negate 方法,正如 and 和 or 方法一样:
基本使用
package demo05; import java.util.function.Predicate; /* 需求:判断一个字符串长度是否大于5 如果字符串的长度大于5,那返回false 如果字符串的长度不大于5,那么返回true 所以我们可以使用取反符号!对判断的结果进行取反 Predicate接口中有一个方法negate,也表示取反的意思 default Predicate<T> negate() { return (t) -> !test(t); } */ public class Demo04Predicate_negate { /* 定义一个方法,方法的参数,传递一个字符串 使用Predicate接口判断字符串的长度是否大于5 */ public static boolean checkString(String s, Predicate<String> pre) { //return !pre.test(s); return pre.negate().test(s);//等效于return !pre.test(s); } public static void main(String[] args) { //定义一个字符串 String s = "abc"; //调用checkString方法,参数传递字符串和Lambda表达式 boolean b = checkString(s, (String str) -> { //判断字符串的长度是否大于5,并返回结果 return str.length() > 5; }); System.out.println(b); } }
练习:集合信息筛选
package demo05; import java.util.ArrayList; import java.util.function.Predicate; /* 练习:集合信息筛选 数组当中有多条“姓名+性别”的信息如下, String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" }; 请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中, 需要同时满足两个条件: 1. 必须为女生; 2. 姓名为4个字。 分析: 1.有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断 2.必须同时满足两个条件,所以可以使用and方法连接两个判断条件 */ public class Demo05Test { /* 定义一个方法 方法的参数传递一个包含人员信息的数组 传递两个Predicate接口,用于对数组中的信息进行过滤 把满足条件的信息存到ArrayList集合中并返回 */ public static ArrayList<String> filter(String[] arr,Predicate<String> pre1,Predicate<String> pre2){ //定义一个ArrayList集合,存储过滤之后的信息 ArrayList<String> list = new ArrayList<>(); //遍历数组,获取数组中的每一条信息 for (String s : arr) { //使用Predicate接口中的方法test对获取到的字符串进行判断 boolean b = pre1.and(pre2).test(s); //对得到的布尔值进行判断 if(b){ //条件成立,两个条件都满足,把信息存储到ArrayList集合中 list.add(s); } } //把集合返回 return list; } public static void main(String[] args) { //定义一个储存字符串的数组 String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" }; //调用filter方法,传递字符串数组和两个Lambda表达式 ArrayList<String> list = filter(array,(String s)->{ //获取字符串中的性别,判断是否为女 return s.split(",")[1].equals("女"); },(String s)->{ //获取字符串中的姓名,判断长度是否为4个字符 return s.split(",")[0].length()==4; }); //遍历集合 for (String s : list) { System.out.println(s); } } }
Function接口
java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据,前者称为前置条件,后者称为后置条件。Function 接口中最主要的抽象方法为: R apply(T t) ,根据类型T的参数获取类型R的结果。使用的场景例如:将 String 类型转换为 Integer 类型。
基本使用
package demo05; import java.util.function.Function; /* java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据, 前者称为前置条件,后者称为后置条件。 Function接口中最主要的抽象方法为:R apply(T t),根据类型T的参数获取类型R的结果。 使用的场景例如:将String类型转换为Integer类型。 */ public class Demo01Function { /* 定义一个方法 方法的参数传递一个字符串类型的整数 方法的参数传递一个Function接口,泛型使用<String,Integer> 使用Function接口中的方法apply,把字符串类型的整数,转换为Integer类型的整数 */ public static void change(String s, Function<String, Integer> fun) { //Integer in = fun.apply(s); int in = fun.apply(s);//自动拆箱 Integer->int System.out.println(in); } public static void main(String[] args) { //定义一个字符串类型的整数 String s = "1234"; //调用change方法,传递字符串类型的整数,和Lambda表达式 change(s, (String str) -> { //把字符串类型的整数,转换为Integer类型的整数返回 return Integer.parseInt(str); }); //优化Lambda change(s, str -> Integer.parseInt(str)); } }
默认方法:andThen
Function 接口中有一个默认的 andThen 方法,用来进行组合操作。该方法同样用于“先做什么,再做什么”的场景,和 Consumer 中的 andThen 差不多:
基本使用
package demo05; import java.util.function.Function; /* Function接口中的默认方法andThen:用来进行组合操作 需求: 把String类型的"123",转换为Inteter类型,把转换后的结果加10 把增加之后的Integer类型的数据,转换为String类型 分析: 转换了两次 第一次是把String类型转换为了Integer类型 所以我们可以使用Function<String,Integer> fun1 Integer i = fun1.apply("123")+10; 第二次是把Integer类型转换为String类型 所以我们可以使用Function<Integer,String> fun2 String s = fun2.apply(i); 我们可以使用andThen方法,把两次转换组合在一起使用 String s = fun1.andThen(fun2).apply("123"); fun1先调用apply方法,把字符串转换为Integer fun2再调用apply方法,把Integer转换为字符串 */ public class Demo02Function_andThen { /* 定义一个方法 参数串一个字符串类型的整数 参数再传递两个Function接口 一个泛型使用Function<String,Integer> 一个泛型使用Function<Integer,String> */ public static void change(String s, Function<String, Integer> fun1, Function<Integer, String> fun2) { String ss = fun1.andThen(fun2).apply(s); System.out.println(ss); } public static void main(String[] args) { //定义一个字符串类型的整数 String s = "123"; //调用change方法,传递字符串和两个Lambda表达式 change(s, (String str) -> { //把字符串转换为整数+10 return Integer.parseInt(str) + 10; }, (Integer i) -> { //把整数转换为字符串 return i + ""; }); //优化Lambda表达式 change(s, str -> Integer.parseInt(str) + 10, i -> i + ""); } }
自定义函数模型拼接
package demo05; import java.util.function.Function; /* 练习:自定义函数模型拼接 题目 请使用Function进行函数模型的拼接,按照顺序需要执行的多个函数操作为: String str = "赵丽颖,20"; 分析: 1. 将字符串截取数字年龄部分,得到字符串; Function<String,String> "赵丽颖,20"->"20" 2. 将上一步的字符串转换成为int类型的数字; Function<String,Integer> "20"->20 3. 将上一步的int数字累加100,得到结果int数字。 Function<Integer,Integer> 20->120 */ public class Demo03Test { /* 定义一个方法 参数传递包含姓名和年龄的字符串 参数再传递3个Function接口用于类型转换 */ public static int change(String s, Function<String, String> fun1, Function<String, Integer> fun2, Function<Integer, Integer> fun3) { //使用andThen方法把三个转换组合到一起 return fun1.andThen(fun2).andThen(fun3).apply(s); } public static void main(String[] args) { //定义一个字符串 String str = "赵丽颖,20"; //调用change方法,参数传递字符串和3个Lambda表达式 int num = change(str, (String s) -> { //"赵丽颖,20"->"20" return s.split(",")[1]; }, (String s) -> { //"20"->20 return Integer.parseInt(s); }, (Integer i) -> { //20->120 return i + 100; }); System.out.println(num); } }