函数式接口的概念:有且仅有一个抽象方法的接口
“语法糖”：指使用更加方便但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这边是“语法糖”。
函数式接口的格式：
修饰符 interface 接口名称{
public abstract 返回值类型 方法名称（可选参数信息）;//其他非抽象方法内容
}
函数式接口：
/* * 函数式接口：有且只有一个抽象方法的接口，称之为函数式接口 * 当然接口中可以包含其他的方法（默认，静态，私有） * @Override注解 * 检查方法是否为重写的方法 * 是：编译成功 * 否：编译失败 * @FunctionalInterface注解 * 作用：检查接口是否是函数式接口 * 是：编译成功 * 否：编译失败（接口中没有抽象方法，抽象方法的个数多于1个） * */ @FunctionalInterface public interface MyFunctionalInterface { //定义一个抽象方法 public abstract void method(); }接口的实现类：
public class MyFunctionalInterfaceImpl implements MyFunctionalInterface{ @Override public void method() { System.out.println("实现类，重写接口中的抽象方法"); } }函数式接口的使用：
/* * 函数式接口的使用：一般可以作为方法的参数和返回值类型 * */ public class Demo { //定义一个方法，参数使用函数式接口MyFunctionalInterface public static void show(MyFunctionalInterface myInter){ myInter.method(); } public static void main(String[] args) { //调用show方法，方法的参数是一个接口，所以可以传递接口的实现类对象 show(new MyFunctionalInterfaceImpl()); //调用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表达式是延迟执行的，这正好可以作为解决方案，提升性能。
性能浪费的日志案例：
/* * 日志案例： * 发现以下代码存在一些性能浪费的问题 * 调用showLog方法，传递的第二个参数是一个拼接后的字符串 * 先把字符串拼接好，然后再调用showLog方法 * showLog方法中如果传递的日志等级不是1级 * 那么就不会输出拼接后的字符串 * 所以感觉字符串就白拼接了，存在浪费 * */ 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); } }使用Lambda优化日志案例：
函数式接口：
@FunctionalInterface public interface MessageBuilder { //定义一个拼接消息的抽象方法 public abstract String buildMessage(); }案例本体：
/* * 使用Lambda优化日志案例： * Lambda特点：延迟加载 * Lambda使用前提：必须存在函数式接口。 * */ public class Demo02Lambda { //定义一个显示日志的方法，方法的参数传递日志的等级和MessageBuilder接口 public static void showLog(int level,MessageBuilder mb){ //对日志的等级进行判断，如果是1级，则调用MessageBuilder接口中的buildMessage方法 if(level==1){ System.out.println(mb.buildMessage()); } } public static void main(String[] args) { //定义三个日志信息 String msg1="Hello"; String msg2="World"; String msg3="Java"; //调用showLog方法，参数MessageBuilder是一个函数式接口，所以可以传递Lambda表达式 showLog(2,()->{ //返回一个拼接好的字符串 return msg1+msg2+msg3; }); /* * 使用Lambda表达式作为参数传递，仅仅是把参数传递到showLog方法中 * 只有满足条件，日志的等级是1级 * 才会调用接口MessageBuilder中的方法buildMessag * 才会进行字符串的拼接 * 如果条件不满足，日志的等级不是1级 * 那么接口MessageBuilder中的方法buildMessag也不好执行 * 所以拼接字符串的代码也不会执行 * 所以不会存在性能的浪费 * */ } }使用Lambda作为参数和返回值：
/* * 例如java.lang.Runnable接口就是一个函数式接口 * 假设有一个startThread方法使用该接口作为参数，那么就可以使用Lambda进行传参 * 这种情况其实和Thread类的构造方法参数为Runnable没有本质区别。 * */ public class Demo03Runnable { //定义一个方法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接口类型的对象作为排序器时，就可以调该方法获取。 * */ public class Demo04Comparator { //定义一个方法，方法的返回值类型使用函数式接口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={"aaaa","b","cccccc","ddddddddd"}; //输出排序前的数组 System.out.println(Arrays.toString(arr));//[aaaa, b, cccccc, ddddddddd] //调用Arrays中的sort方法，对字符串数组进行排序 Arrays.sort(arr,getComparator()); //输出排序后的数组 System.out.println(Arrays.toString(arr));//[ddddddddd, cccccc, aaaa, b] } }常用的函数式接口_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 s1=getString(()-> "胡歌"); System.out.println(s1); } } /* * 练习：求数组元素最大值 * 使用Supplier接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值。 * 提示：接口的泛型请使用java.lang.Integer类 * */ public class Demo02Supplier { //定义一个方法，用于获取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,88,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); } }
