函数式接口

函数式接口在java中指的就是；有且仅有一个抽象方法的接口； 函数式接口，适用于函数式编程场景的接口。而java中Lambda就是函数式编程的体现之一，只有确保接口中有且仅有一个抽象方法，java中的Lambda表达式才能顺利的进行推导。 为了确保一个接口中只有一个抽象方法，java8中专门为函数式接口引入了一个新得注解； @FunctionalInterface注解；该注解用于一个接口的定义上 一旦使用了这个注解，编译器就会强制的检查该接口是否有且仅有一个抽象方法，否则就会报错。 （如果没有使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来并无差异）

代码演示（接口）

@FunctionalInterface public interface MyFunctionalInterface { void method(); }

代码演示（测试）

public class Demotext { //定义一个方法，参数使用函数式接口MyFunctionalInterface public static void show(MyFunctionalInterface myinter){ myinter.method(); } public static void main(String[] args) { //调用show方法，方法的参数是一个接口，所以我们可以传递接口的匿名内部类 show(new MyFunctionalInterface() { @Override public void method() { System.out.println("我是一个函数式接口匿名内部类，我输出了一个2"); } }); //调用show方法，方法的参数是一个函数式接口，我们可以使用lambda表达式 show(() -> { System.out.println("我是一个函数式接口lambda表达式，我输出了一个3"); }); //（简化）调用show方法，方法的参数是一个函数式接口，我们可以使用lambda表达式 show(() ->System.out.println("我是一个函数式接口lambda表达式（简化），我输出了一个4")); } }

函数式编程中Lambda的延迟问题以及代码的优化 如果我写了一个普通的日志案例； （接口）

public interface LoggerInterface { String showLogdemo(); }

（案例）

public class Demo01Logger { public static void showLog(int lever ,String message){ if(lever == 1){ System.out.println(message); } } public static void main(String[] args) { String msg1 = "abc"; String msg2 ="cvb"; String msg3 ="ads"; showLog(1,msg2+msg1+msg3); } }

这样子写的话，也可以实现我想要实现的功能，但是在我们的实际开发中，追求的是高效率，高性能，上面的案例中，存在一个很大的问题；

那就是在调用showlog方法的时候，他传递的第二个参数是一个拼接后的字符串，他的执行顺序是先把字符串拼接好，在调用showlog方法，如果showlog方法中传递的日志等级不是1的话，那么就存在一个性能浪费的问题。

那么该怎么解决这个问题，是我们现在应该思考的。 优化方案； Lambda表达式有一个特点，那就是延迟执行 代码改造；

public class Demo01Logger02 { public static void showlog(int lever ,LoggerInterface msg){ if(lever ==1){ System.out.println(msg.showLogdemo()); } } public static void main(String[] args) { String msg1 = "abc"; String msg2 ="cvb"; String msg3 ="ads"; showlog(1,()->{ return msg1+msg2+msg3; }); } }

这样一来，我们便解决了刚刚的问题； 使用Lambda表达式作为参数传递，仅仅是把参数传递到showLog方法中，只有满足条件时才会调用接口LoggerInterface中的方法，才会进行字符串拼接，如果条件不满足，那么LoggerInterface接口中的方法也不会执行，所以不会存在性能的浪费。

还可以使用Lambda作为参数和返回值； 说的简单些，使用Lambda表达式作为方法的参数，其实就是使用函数式接口作为方法的参数。 案例实现

public class Demo01Runnable { public static void startThread(Runnable run){ // 调用Thread中的run方法，在调用start方法，开启一个多线程 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()+"-->"+"线程启动了")); } }

java.util.Runnable接口就是一个函数式接口，定义一个StartThread方法使用该接口作为参数，那么就可以使用Lambda进行传参操作；

还可以使用Lambda作为返回值 案例一； 按照以前的写法如果我们想对一组数组进行排序，需要定义一个方法，方法的返回值类型使用函数式接口Comparator，由于方法的返回值是一个接口，我们可以直接返回这个接口的匿名内部类，从而在return中定义我们的排序规则。在主方法中，在进行一次调用 代码实现；

public static Comparator<String> getComparator(){ //方法的返回值是一个接口，直接返回此接口的匿名内部类 return new Comparator<String>() { @Override public int compare(String o1, String o2) { //按照字符串的降序排序 return 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] } }

案例二； 使用Lambda表达式，优化上面的代码

方法的返回值是一个函数式接口，所以我们可以返回一个Lambda表达式 代码实现

public static Comparator<String> getComparator(){ /*return (String o1, String o2)->{ return o2.length()-o1.length(); };*/ //优化 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] } }

可以明显的看到代码量已经减少。

其他的一些常用的函数式接口（主要在function包中提供）

第一个（Supplier接口）官方定义；用来获取一个泛型参数指定类型的对象数据。 其实就是获取数据（包含一个get方法） 代码实现

//泛型中定义的是String类型，那么获取的数据也应该是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<T>接口被称之为生产型接口,指定接口的泛型是什么类型,那么接口中的get方法就会生产什么类型的数据

第二个：Consumer接口，这个接口是消费一个数据，与刚刚的Supplier接口正好相反（包含一个） 泛型执行什么类型,就可以使用accept方法消费什么类型的数据，至于具体怎么消费(使用),需要自定义(输出,计算…) 代码实现；

public static void method(String name, Consumer<String> con){ con.accept(name); } public static void main(String[] args) { //调用method方法，传递字符串姓名，由于后面的参数是一个函数式接口，所以可以使用Lambda表达式 method("赵丽颖",(String name)->{ //链式编程，把字符串进行反转输出 String reName = new StringBuffer(name).reverse().toString(); System.out.println(reName); }); } }

默认andThen方法 在Consumer接口中，有一个默认方法，他可以把两个或两个以上Consumer类型的操作进行组合。

public static void method(String s, Consumer<String> con1 ,Consumer<String> con2){ con1.andThen(con2).accept(s); } public static void main(String[] args) { ethod("Hello", (t)->{ //消费方式:把字符串转换为大写输出 System.out.println(t.toUpperCase()); }, (t)->{ //消费方式:把字符串转换为小写输出 System.out.println(t.toLowerCase()); }); } }

注意： java.util.Objects的requireNoneNull静态方法将会在参数为null时主动抛出NullPointerException异常，这样就省去了重复编写if语句和抛出空指针异常的麻烦。

案例；格式化打印信息；

public static void printInfo(String[] arr, Consumer<String> con1,Consumer<String> con2){ //遍历字符串数组 for (String message : arr) { //使用andThen方法连接两个Consumer接口,消费字符串 con1.andThen(con2).accept(message); } } public static void main(String[] args) { //定义一个字符串类型的数组 String[] arr = { "小红,女", "小兰,女", "小明,男" }; 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接口； 当我们需要对某种类型的数据进行判断时，从而得到一个Boolean类型的结果，这时就可以使用java.util.function.Predicate 接口 此接口有几个常用的方法； （1），抽象方法test----->boolean test(T t).用于条件判断的场景； （2），默认方法and------>对照条件判断，存在与或非三种常见的逻辑关系，此and也可以实现“并且”的效果； （3），默认方法or--------->实现逻辑关系中的“或” （4），默认方法negate------------>实现逻辑关系中的“非” 以下一一实现； （1），test方法 boolean test(T t);用来对指定数据类型数据进行判断的方法 结果; 符合条件；返回true 不符合条件：返回false

案例实现；（步骤） （1），定义一个方法，传递String类型的字符串 （2），传递一个Predicate接口，泛型使用String （3），使用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); } }

（2）and方法；表示并且的关系，也可以用于连续两个判断条件 案例实现（步骤） （1），定义一个方法，方法的参数，传递一个字符串 （2），传递两个Predicate接口 其中一个接口用于判断字符串的长度是否大于3 一个用于判断字符串中是否包含a 两个条件必须同时满足才可以返回true

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); } public static void main(String[] args) { String s = "abcdef"; //调用checkString方法,参数传递字符串和两个Lambda表达式 boolean b = checkString(s, (String str)->{ //判断字符串的长度是否大于3 return str.length()>3; }, (String str)->{ //判断字符串中是否包含a return str.contains("a"); }); System.out.println(b); } }

（3）or方法；表示或者的关系，也可以用于连接另个判断条件 案例实现（步骤） （1），定义一个方法，方法的参数，传递一个字符串 （2），传递两个Predicate接口 一个用于判断字符串的长度是否大于3 一个判断字符串是否包含a 满足一个条件就返回true

看代码；

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); } public static void main(String[] args) { String s = "abcdef"; //调用checkString方法,参数传递字符串和两个Lambda表达式 boolean b = checkString(s, (String str)->{ //判断字符串的长度是否大于3 return str.length()>3; }, (String str)->{ //判断字符串中是否包含a return str.contains("a"); }); System.out.println(b); } }

(4),negate方法；取反的意思“！” 案例实现（步骤） （1），定义一个方法，方法的参数，传递一个字符串 （2），使用Predicate接口判断字符串的长度是否大于3 如果不大于3就返回true

看代码

public static boolean checkString(String s, Predicate<String> pre){ return pre.negate().test(s); } public static void main(String[] args) { String s = "ab"; boolean b = checkString(s,(String str)->{ return str.length()>3; }); System.out.println(b); } }

案例应用；（集合信息的筛选） 条件（必须为女生，姓名必须是四个字）

import java.util.ArrayList; import java.util.List; import java.util.function.Predicate; public class DemoPredicate { public static void main(String[] args) { String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" }; List<String> list = filter(array, s ‐> "女".equals(s.split(",")[1]), s ‐> s.split(",")[0].length() == 4); System.out.println(list); } private static List<String> filter(String[] array, Predicate<String> one, Predicate<String> two) { List<String> list = new ArrayList<>(); for (String info : array) { if (one.and(two).test(info)) { list.add(info); } } return list; } }

（4），Function接口； java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件， 后者称为后置条件。 抽象方法apply Function接口中最主要的抽象方法；R apply（T t），根据类型T的参数湖区类型R的结果 案例； 将String类型转换为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 和 Consumer 中的 andThen 差不多

案例实现；

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+""); } }

练习；自定义函数模型的拼接； 分析: 1. 将字符串截取数字年龄部分，得到字符串； Function<String,String> “赵丽颖,20”->“20” 2. 将上一步的字符串转换成为int类型的数字； Function<String,Integer> “20”->20 3. 将上一步的int数字累加100，得到结果int数字。 Function<Integer,Integer> 20->120

代码实现；

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); } }

还有其他的一些函数式接口，上面的都是一些较为常用的。 后续，还会有一些Stream流与方法的引用，这些内容敬请期待。 再此声明：以上全部内容，均属于个人笔记，目的只是为了方便记忆与回顾，无其他商业用途。如需转载，请注明出处。