Lambda表达式
1.函数式编程思想概述
在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法--强调做什么，而不是以什么形式做
面向对象的思想：
做一件事情，找一个能解决这个事情的对象，调用对象的方法，完成事情
函数式编程思想：
只要获取到结果，谁去做的，怎么做的都不重要，重视的是结果，不重视过程
2.Lambda表达式的标准格式
由三部分组成：
一些参数
一个箭头
一段代码
格式：
（参数列表）-> {一些重写方法的代码}
解释说明格式：
（）：接口中抽象方法的参数列表，没有参数，就空着；有参数，就写出参数，多个参数，使用逗号分隔
-> ：传递的意思，把参数传递给方法体
{} ：重写接口的抽象方法的方法体
案例1：Lambda表达式无参数无返回值
需求：
* 给定一个厨子Cook接口，内含唯一的抽象方法makeFood，且无参数，无返回值
* 使用Lambda标准格式调用invokeCook方法，打印输出“吃饭啦”字样
package cn.yjg.day10.Lambda;
/**
* 需求：
* 给定一个厨子Cook接口，内含唯一的抽象方法makeFood，且无参数，无返回值
* 使用Lambda标准格式调用invokeCook方法，打印输出“吃饭啦”字样
*/
public class Demo01Cook {
public static void main(String[] args) {
// 调用invokeCook方法，参数是Cook接口，传递Cook接口的匿名内部类对象
invokeCook(new Cook() {
@Override
public void makeFood() {
System.out.println("吃饭啦");
}
});
// 使用Lambda表达式简化匿名内部类的书写
invokeCook(() -> {
System.out.println("吃饭啦");
});
}
// 定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeFood
public static void invokeCook(Cook cook) {
cook.makeFood();
}
}
运行结果：
案例2：Lambda表达式有参数有返回值的
需求：
使用数组存储多个Person对象
对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序
使用一般的方法
Person.java
package com.company.service.Lambda;
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
}
}
Demo01Arrays.java
package com.company.service.Lambda;
import java.util.Arrays;
import java.util.Comparator;
public class Demo01Arrays {
public static void main(String[] args) {
// 使用数组存储多个Person对象
Person[] arr = {
new Person("陈钰琪", 20),
new Person("古力娜扎", 22),
new Person("关之琳", 52),
};
// 对数组中的Person对象使用Arrays的sort方法通过年龄进行排序（前边-后边）
Arrays.sort(arr, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge()-o2.getAge();
}
});
// 遍历数组，使用增强for循环
for (Person person : arr) {
System.out.println(person);
}
}
}
结果：
使用Lambda，简化匿名内部类
package com.company.service.Lambda;
import java.util.Arrays;
public class Demo02Arrays {
public static void main(String[] args) {
// 使用数组存储多个Person对象
Person[] arr = {
new Person("陈钰琪", 20),
new Person("古力娜扎", 22),
new Person("关之琳", 52),
};
// 对数组中的Person对象使用Arrays的sort方法通过年龄进行排序（前边-后边）
Arrays.sort(arr, (Person o1, Person o2) -> {
return o1.getAge()-o2.getAge();
});
// 遍历数组，使用增强for循环
for (Person person : arr) {
System.out.println(person);
}
}
}
案例3：
需求：
给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算
Calulator.java
package com.company.service.Lambda;
public interface Calculator {
// 定义一个计算两个int整数和的方法并返回结果
public abstract int calc(int a, int b);
}
一般的方法
package com.company.service.Lambda;
public class Demo02Calculator {
public static void main(String[] args) {
// 调用invokeCalc方法，方法的参数是一个接口，可以使用匿名内部类
invokeCalc(120, 130, new Calculator() {
@Override
public int calc(int a, int b) {
return a+b;
}
});
}
/**
* 定义一个方法，参数传递两个int类型的整数，
* 参数传递Calculator接口，
* 方法内部调用Calculator中的方法calc计算两个整数的和
*/
public static void invokeCalc(int a, int b, Calculator c) {
int sum = c.calc(a, b);
System.out.println(sum);
}
}
使用Lambda简化匿名内部类
package com.company.service.Lambda;
public class Demo03Calculator {
public static void main(String[] args) {
// 调用invokeCalc方法，方法的参数是一个接口，可以使用匿名内部类
invokeCalc(120, 130,(int a, int b) -> {
return a+b;
});
}
/**
* 定义一个方法，参数传递两个int类型的整数，
* 参数传递Calculator接口，
* 方法内部调用Calculator中的方法calc计算两个整数的和
*/
public static void invokeCalc(int a, int b, Calculator c) {
int sum = c.calc(a, b);
System.out.println(sum);
}
}
3.Lambda省略格式
可推导，那就可省略
Lambda强调的是“做什么”而不是“怎么做”，所以凡是可以根据上下文推导得知的信息，都可以省略，例如可以写成
invokeCalc(120, 130, (a, b) -> a+b);
可以省略的内容：
（1）（参数列表）：括号中参数列表的数据类型，可以省略不写
（2）（参数列表）：括号中的参数如果只有一个，那么类型和（）都可以省略
（3）{一些代码}：如果{}中的代码只有一行，无论是否有返回值，都可以省略{}，return，分号
注意：要省略这三个{}，return，分号，必须要一起省略，
体现可推导可省略的例子
4.Lambda使用前提
1.使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
无论是JDK内置的Runnable，Comparator接口还是自定义的接口，只有当接口的抽象方法存在唯一时，才可以使用Lambda
2.使用Lambda必须具有上下文推断
也就是方法的参数或局部变量的类型必须是Lambda对应的接口类型，才能使用Lambda作为该接口的实例
备注：
有且仅有一个抽象方法的接口，称为函数式接口
