常用的函数式接口_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接口的默认方法andThem * 作用：需要两个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 name, Consumer<String> con1,Consumer<String> con2){ /*con1.accept(name); con2.accept(name);*/ //使用andThen方法，把两个Consumer接口连接在一起，再消费数据 con1.andThen(con2).accept(name);//con1连接con2,先执行con1消费数据，再执行con2消费数据 } public static void main(String[] args) { //调用method方法，传递一个字符串，两个Lambda表达式 method("Hello",(name)->{ //消费方式：把字符串转换为大写输出 System.out.println(name.toUpperCase()); },(name)->{ //消费方式：把字符串转换为小写输出 System.out.println(name.toLowerCase()); }); } }练习：格式化打印信息：
/* * 练习： * 字符串数组当中存在多条信息，请按照“姓名：XX。性别：XX。”的格式将信息打印出来。 * 要求将打印姓名的动作作为第一个Consumer接口的Lambda实例， * 将打印性别的动作作为第二个Consumer接口的Lambda实例， * 将两个Consumer接口按照顺序“拼接”到一起。 * */ public class Demo03Test { //定义一个方法，参数传递String类型的数组和两个Consumer接口，泛型使用String public static void printInfo(String[] arr, Consumer<String> con1,Consumer<String> con2){ //遍历字符串数组 for(String message:arr){ //使用andThem方法连接两个Consumer接口，消费字符串 con1.andThen(con2).accept(message); } } public static void main(String[] args) { //定义一个字符串类型的数组 String[] arr={"迪丽热巴，女","胡歌，男","迪丽热巴，女"}; //调用printInfo方法，传递一个字符串数组，和两个Lambda表达式 printInfo(arr,(message)->{ //消费方式：对Message进行切割，获取姓名，按照指定的格式输出 String name = message.split("，")[0]; System.out.print("姓名:"+name); },(message)->{ //消费方式：对Message进行切割，获取年龄，按照指定的格式输出 String age = message.split("，")[1]; System.out.println("。年龄："+age+"。"); }); } }常用的函数式接口_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表达式 //调用checkString方法对字符串进行校验，参数传递字符串和Lambda表达式 boolean b=checkString(s,(str)-> str.length()>5); System.out.println(b); } }Predicate接口默认方法：and：
/* * 逻辑表达式：可以连接多个判断的条件 * &&:与运算符，有false则false * ||：或运算符，有true则true * ！：非（取反）运算符：非真则假，非假则真 * 需求： * 判断一个字符串，有两个判断的条件 * 1.字符串的长度是否大于5 * 2.判断字符串中是否包含a * 两个条件必须同时满足，我们就可以使用与运算符连接两个条件 * Predicate接口中有一个方法and，表示并且关系，也可以用于连接两个判断 * 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)->{ return str.contains("a"); }); System.out.println(b); } }Predicate接口默认方法：or：
/* * 需求： * 判断一个字符串，有两个判断的条件 * 1.字符串的长度是否大于5 * 2.判断字符串中是否包含a * 满足一个条件即可，我们就可以使用||运算符连接两个条件 * Predicate接口中有一个方法or，表示或者关系，也可以用于连接两个判断 * default Predicate<T> and(Predicate<? super T> other){ * Objects.requireNonNull(other); * return (t)->this.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="acdef"; //调用checkString方法，参数传递字符串和两个Lambda表达式 boolean b=checkString(s,(String str)->{ //判断字符串的长度是否大于5 return str.length()>5; },(String str)->{ return str.contains("a"); }); System.out.println(b); } }Predicate接口默认方法：negate：
/* * 需求：判断一个字符串的长度是否大于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); } }Predicate接口练习：
/* * 练习：集合信息筛选 * 数组当中有多条“姓名+性别”的信息如下： * String[] array={"迪丽热巴，女","古力娜扎，女","马尔扎哈，男","赵丽颖，女"}; * 请通过Predicate接口的拼装将符合条件的字符串筛选到集合ArrayList中， * 需要同时满足两个条件： * 1.必须为女生 * 2.姓名为4个字 * 分析： * 1.有两个判断条件，所以需要两个Predicate接口，对条件进行判断 * 2.必须同时满足两个条件，所以可以使用and方法连接两个判断条件 * */ public class Demo05Test { /* * 定义一个方法，方法的参数传递一个包含人员信息的数组 * 传递两个Predicate接口，用于对数组中的信息进行过滤 * 把满足条件的信息存到ArrayList集合中并返回 * */ public static ArrayList<String> filter(String[] array, Predicate<String> pre1,Predicate<String> pre2){ //定义一个ArrayList集合，存储过滤之后的信息 ArrayList<String> list=new ArrayList<>(); //遍历数组，获取数组中的每一条信息 for (String s : array) { //使用Predicate接口中的方法test对获取到的字符串进行判断 boolean b = pre1.and(pre2).test(s); //对得到的布尔值进行判断 if(b){ //条件成立，两个条件都满足，把信息存储到ArrayList中 list.add(s); } } //把集合返回 return list; } public static void main(String[] args) { //定义一个存储字符串的数组 String[] arr={"迪丽热巴，女","古力娜扎，女","马尔扎哈，男","赵丽颖，女"}; //调用filter方法,传递字符串数组和两个Lambda表达式 ArrayList<String> list=filter(arr,(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类型。 **/ 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)); } }Function接口中默认方法_andThen:
/* * Function接口中的默认方法andThen：用来进行组合操作 * 需求：把String类型的“123”，转换为Integer类型，把转换后的结果加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+""); } }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 Demo03FunctionTest { /* * 定义一个方法 * 参数传递包含姓名和年龄的字符串 * 参数再传递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)->{ return Integer.parseInt(s); },(Integer i)->{ //20->120 return i+100; }); System.out.println(num); } }