H2_函数式接口

一、函数式接口

1.概念
函数式接口在 java中指：有且仅有一个抽象方法方法的接口，当然接口中还可以包括其他的方法(默认，静态，私有)

函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

• 备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。

//定义函数式接口

/*
    @FunctionalInterface注解
    作用：检测接口是否为函数式接口
        是：编译成功
        否：编译失败(接口中没有抽象方法/抽象方法的个数大于1)
*/
@FunctionalInterface
public interface D01Interface {
    //定义一个抽象方法
    public abstract void method();
//    void method2(); //只能有一个抽象方法
}

//函数式接口的使用

/*
	函数式接口的使用：一般可以作为方法的参数和返回值类型
*/
public class D01Test {
	//定义一个方法，参数使用函数式接口D01Interface
    public static void show(D01Interface myInt){
        myInt.method();
    }

    public static void main(String[] args) {
        //调用show方法，方法的参数是一个接口，所以可以传递接口的实现类对象
        show(new D01Interface() {
            @Override
            public void method() {
                System.out.println("使用匿名内部类重写接口中的抽象方法");
            }
        });

        //调用show方法，方法的参数是一个接口，所以可以传递Lambda表达式
        show(()->{
            System.out.println("使用Lambda表达式重写接口中的抽象方法");
        });
        //简化
        show(()-> System.out.println("使用简化Lambda表达式重写接口中的抽象方法"));
    }
}

Lambda和匿名内部类实现相同功能，但是内部实现原理是不同的，lambda效率高一点。

---

一、函数式编程

1. Lambda的延迟执行
   有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以作为解决方案，提升性能。

• 日志案例：
  //优化前：

/*
 	日志案例：
 	发现以下代码存在一些性能浪费的问题：
 		调用showLog方法，传递的第二个参数是一个拼接后字符串
 		先把字符串拼接好，再调用showLog
 		如果showLog方法中传递的日至等级不是1级，那么就不会输出拼接后的字符，存在浪费
 */
public class D02Log {
	//定义一个根据日志的级别，显示日志信息的方法
	public static void showLog(int level,String msg) {
		//对日志的等级进行判断，如果是1则输出日志信息
		if(level == 1) {
			System.out.println(msg);
		}
	}
	public static void main(String[] args) {
		String msg1 = "hello"; 
		String msg2 = "world"; 
		String msg3 = "java"; 
		
		//调用showLog()
		showLog(2, msg1+msg2+msg3);
	}
}

//优化后：

@FunctionalInterface
public interface D02MegBuilder {
	//定义一个拼接消息的抽象方法，返回拼接的消息
	public abstract String builerMsg();
}

/*
 	使用Lambda优化日志案例：
 		Lambda的特点：延迟加载
 		Lambda的使用前提，必须存在函数式接口
 */
public class D02Lambda {
	//定义一个显示日志的方法，方法的参数传递日志的等级和D02MegBuilder接口
	public static void showLog(int level,D02MegBuilder mb) {
		//对日志的等级进行判断，如果是1则调用D02MegBuilder接口中的builerMsg方法
		if(level == 1) {
			System.out.println(mb.builerMsg());
		}
	}
	public static void main(String[] args) {
		String msg1 = "hello"; 
		String msg2 = "world"; 
		String msg3 = "java"; 
		
		//调用showLog(),参数D02MegBuilder是一个函数式接口，所以可以传递Lambda表达式
		showLog(1,()->{
			//返回一个拼接好的字符串
			return msg1+msg2+msg3;    //helloworldjava
		});
		/*
		 	使用Lambda表达式作为参数传递，仅仅是把参数传递到showLog方法中
		 	只有满足条件，日志等级是1级，才会调用接口D02MegBuilder中的方法builerMsg，才会进行字符串的拼接
		 	如果条件不满足，那么D02MegBuilder中的方法builerMsg不会执行，不执行拼接字符串，不会存在性能的浪费
		 */
	}
}

---

2. 使用Lambda作为参数和返回值
   如果抛开实现原理不说，Java中的Lambda表达式可以被当作是匿名内部类的替代品。
   如果方法的参数是一个函数式接口类型，那么就可以使用Lambda表达式进行替代。使用Lambda表达式作为方法参数，其实就是使用函数式接口作为方法参数。

• 01使用Lambda作为方法的参数
  java.lang.Runnable 接口就是一个函数式接口，假设有一个 startThread 方法使用该接口作为参数，那么就可以使用Lambda进行传参。这种情况其实和 Thread 类的构造方法参数为Runnable 没有本质区别。

public class D03Runnable {
	//定义一个方法，方法的餐宿使用函数式接口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()+" --> 线程启动了");  //Thread-0 --> 线程启动了
			}
		});
		
		//使用Lambda优化，run方法没有参数
		//使用前提：方法的参数是一个函数式接口
		startThread(()->System.out.println(Thread.currentThread().getName()+" --> 线程启动了")); //Thread-1 --> 线程启动了
	}
}

• 02使用Lambda作为方法的返回值
  如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式。
  当需要通过一个方法来获取一个 java.util.Comparator 接口类型的对象作为排序器时,就可以调该方法获取。

public class D04Comparator {
	//定义一个方法，方法的返回值类型使用函数式接口 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();
		};
		*/
		
		return (o1, o2) -> o2.length() - o1.length(); //省略return，{} ，参数类型
	}
	
	public static void main(String[] args) {
		//创建一个字符串数组
		String[] arr = {"aaa","b","ccccc","ddddddd"};
		//输出排序前的字符串
		System.out.println("排序前的字符串数组"+Arrays.toString(arr)); //[aaa, b, ccccc, ddddddd]
		//调用Arrays中的sort方法，对字符串数组进行排序
		Arrays.sort(arr, getComparator());
		//输出排序后的字符串
		System.out.println("排序后的字符串数组"+Arrays.toString(arr));  //[ddddddd, ccccc, aaa, b]
	}
}

整理：
作为方法的参数返回，是在方法被调用的时候，把方法的参数直接替换为Lambda表达式。
作为方法的返回值类型，是在定义方法的时候，返回的内容为Lambda表达式。