Lambda表达式（详细讲解）
Lambda表达式
3.1 函数式编程思想概述
[外链图⽚转存失败，源站可能有防盗链机制，建议将图⽚保存下来直接上传(img-S4mxZT6r-1614232071649)
(C:/Users/ThinkPad/Desktop/md/img/03-Overview.png)]
在数学中，函数就是有输⼊量、输出量的⼀套计算⽅案，也就是“拿什么东西做什么事情”。相对⽽⾔，⾯向对象过分强调“必须通过对象的形式来做事情”，⽽函数式思想则尽量忽略⾯向对象的复杂语法——强调做什么，⽽不是以什么形式做。
⾯向对象的思想:
做⼀件事情，⼀个能解决这个事情的对象，调⽤对象的⽅法，完成事情.
函数式编程思想:
只要能获取到结果，谁去做的，怎么做的都不重要，重视的是结果，不重视过程
3.2 冗余的Runnable代码
传统写法
当需要启动⼀个线程去完成任务时，通常会通过java.lang.Runnable接⼝来定义任务内容，并使⽤java.lang.Thread类来启动该线程。代码如下：
public class Demo01Runnable {
public static void main(String[] args){
// 匿名内部类
lambda编程Runnable task =new Runnable(){
@Override
public void run(){// 覆盖重写抽象⽅法
System.out.println("多线程任务执⾏！");
}
};
new Thread(task).start();// 启动线程
}
}
本着“⼀切皆对象”的思想，这种做法是⽆可厚⾮的：⾸先创建⼀个Runnable接⼝的匿名内部类对象来指定任务内容，再将其交给⼀个线程来启动。
代码分析
对于Runnable的匿名内部类⽤法，可以分析出⼏点内容：
Thread类需要Runnable接⼝作为参数，其中的抽象run⽅法是⽤来指定线程任务内容的核⼼；
为了指定run的⽅法体，不得不需要Runnable接⼝的实现类；
为了省去定义⼀个RunnableImpl实现类的⿇烦，不得不使⽤匿名内部类；
必须覆盖重写抽象run⽅法，所以⽅法名称、⽅法参数、⽅法返回值不得不再写⼀遍，且不能写错；
⽽实际上，似乎只有⽅法体才是关键所在。
3.3 编程思想转换
做什么，⽽不是怎么做
我们真的希望创建⼀个匿名内部类对象吗？不。我们只是为了做这件事情⽽不得不创建⼀个对象。我们真正希望做的事情是：将run⽅法体内的代码传递给Thread类知晓。
传递⼀段代码——这才是我们真正的⽬的。⽽创建对象只是受限于⾯向对象语法⽽不得不采取的⼀种⼿段⽅式。那，有没有更加简单的办法？如果我们将关注点从“怎么做”回归到“做什么”的本质上，就会发现只要能够更好地达到⽬的，过程与形式其实并不重要。
⽣活举例
[外链图⽚转存失败，源站可能有防盗链机制，建议将图⽚保存下来直接上传(img-VRimymix-1614232071653)
(C:/Users/ThinkPad/Desktop/md/img/01-%E4%BA%A4%E9%80%9A%E6%96%B9%E5%BC%8F.png)]
当我们需要从北京到上海时，可以选择⾼铁、汽车、骑⾏或是徒步。我们的真正⽬的是到达上海，⽽如何才能到达上海的形式并不重要，所以我们⼀直在探索有没有⽐⾼铁更好的⽅式——搭乘飞机。
[外链图⽚转存失败，源站可能有防盗链机制，建议将图⽚保存下来直接上传(img-bxMlMJfm-1614232071657)
(C:/Users/ThinkPad/Desktop/md/img/02-Lambda.png)]
⽽现在这种飞机（甚⾄是飞船）已经诞⽣：2014年3⽉Oracle所发布的Java 8（JDK 1.8）中，加⼊了Lambda表达式的重量级新特性，为我们打开了新世界的⼤门。
3.4 体验Lambda的更优写法
借助Java 8的全新语法，上述Runnable接⼝的匿名内部类写法可以通过更简单的Lambda表达式达到等效：
public class Demo02LambdaRunnable {
public static void main(String[] args){
new Thread(()-> System.out.println("多线程任务执⾏！")).start();// 启动线程
}
}
这段代码和刚才的执⾏效果是完全⼀样的，可以在1.8或更⾼的编译级别下通过。从代码的语义中可以看出：我们启动了⼀个线程，⽽线程任务的内容以⼀种更加简洁的形式被指定。
不再有“不得不创建接⼝对象”的束缚，不再有“抽象⽅法覆盖重写”的负担，就是这么简单！
3.5 回顾匿名内部类
Lambda是怎样击败⾯向对象的？在上例中，核⼼代码其实只是如下所⽰的内容：
()-> System.out.println("多线程任务执⾏！")
为了理解Lambda的语义，我们需要从传统的代码起步。
使⽤实现类
要启动⼀个线程，需要创建⼀个Thread类的对象并调⽤start⽅法。⽽为了指定线程执⾏的内容，需要调⽤Thread类的构造⽅法：public Thread(Runnable target)
为了获取Runnable接⼝的实现对象，可以为该接⼝定义⼀个实现类RunnableImpl：
public class RunnableImpl implements Runnable {
@Override
public void run(){
System.out.println("多线程任务执⾏！");
}
}
然后创建该实现类的对象作为Thread类的构造参数：
public class Demo03ThreadInitParam {
public static void main(String[] args){
Runnable task =new RunnableImpl();
new Thread(task).start();
}
}
使⽤匿名内部类
这个RunnableImpl类只是为了实现Runnable接⼝⽽存在的，⽽且仅被使⽤了唯⼀⼀次，所以使⽤匿名内部类的语法即可省去该类的单独定义，即匿名内部类：
public class Demo04ThreadNameless {
public static void main(String[] args){
new Thread(new Runnable(){
@Override
public void run(){
System.out.println("多线程任务执⾏！");
}
}).start();
}
}
匿名内部类的好处与弊端
⼀⽅⾯，匿名内部类可以帮我们省去实现类的定义；另⼀⽅⾯，匿名内部类的语法——确实太复杂了！
语义分析
仔细分析该代码中的语义，Runnable接⼝只有⼀个run⽅法的定义：
public abstract void run();
即制定了⼀种做事情的⽅案（其实就是⼀个函数）：
⽆参数：不需要任何条件即可执⾏该⽅案。
⽆返回值：该⽅案不产⽣任何结果。
代码块（⽅法体）：该⽅案的具体执⾏步骤。
同样的语义体现在Lambda语法中，要更加简单：
()-> System.out.println("多线程任务执⾏！")
前⾯的⼀对⼩括号即run⽅法的参数（⽆），代表不需要任何条件；
中间的⼀个箭头代表将前⾯的参数传递给后⾯的代码；
后⾯的输出语句即业务逻辑代码。
3.6 Lambda标准格式
Lambda省去⾯向对象的条条框框，格式由3个部分组成：
⼀些参数
⼀个箭头
⼀段代码
Lambda表达式的标准格式为：
(参数类型参数名称) -> { 代码语句 }
格式说明：
⼩括号内的语法与传统⽅法参数列表⼀致：⽆参数则留空；多个参数则⽤逗号分隔。
->是新引⼊的语法格式，代表指向动作。
⼤括号内的语法与传统⽅法体要求基本⼀致。
3.7 练习：使⽤Lambda标准格式（⽆参⽆返回）
题⽬
给定⼀个厨⼦Cook接⼝，内含唯⼀的抽象⽅法makeFood，且⽆参数、⽆返回值。如下：
public interface Cook {
void makeFood();
}
在下⾯的代码中，请使⽤Lambda的标准格式调⽤invokeCook⽅法，打印输出“吃饭啦！”字样：
public class Demo05InvokeCook {
public static void main(String[] args){
// TODO 请在此使⽤Lambda【标准格式】调⽤invokeCook⽅法
}
private static void invokeCook(Cook cook){
cook.makeFood();
}
}
解答
public static void main(String[] args){
invokeCook(()->{
System.out.println("吃饭啦！");
});
}
备注：⼩括号代表Cook接⼝makeFood抽象⽅法的参数为空，⼤括号代表makeFood的⽅法体。
3.8 Lambda的参数和返回值
需求:
使⽤数组存储多个Person对象
对数组中的Person对象使⽤Arrays的sort⽅法通过年龄进⾏升序排序
下⾯举例演⽰java.util.Comparator<T>接⼝的使⽤场景代码，其中的抽象⽅法定义为：
public abstract int compare(T o1, T o2);
当需要对⼀个对象数组进⾏排序时，Arrays.sort⽅法需要⼀个Comparator接⼝实例来指定排序的规则。假设有⼀个Person类，含有String name和int age两个成员变量：
public class Person {
private String name;
private int age;
// 省略构造器、toString⽅法与Getter Setter
}
传统写法
如果使⽤传统的代码对Person[]数组进⾏排序，写法如下：
import java.util.Arrays;
import java.util.Comparator;
public class Demo06Comparator {
public static void main(String[] args){
// 本来年龄乱序的对象数组
Person[] array ={
new Person("古⼒娜扎",19),
new Person("迪丽热巴",18),
new Person("马尔扎哈",20)};
// 匿名内部类
Comparator<Person> comp =new Comparator<Person>(){
@Override
public int compare(Person o1, Person o2){
Age()- o2.getAge();
}
};
Arrays.sort(array, comp);// 第⼆个参数为排序规则，即Comparator接⼝实例
for(Person person : array){
System.out.println(person);
}
}
}
这种做法在⾯向对象的思想中，似乎也是“理所当然”的。其中Comparator接⼝的实例（使⽤了匿名内部类）代表了“按照年龄从⼩到⼤”的排序规则。
代码分析
下⾯我们来搞清楚上述代码真正要做什么事情。
为了排序，Arrays.sort⽅法需要排序规则，即Comparator接⼝的实例，抽象⽅法compare是关键；
为了指定compare的⽅法体，不得不需要Comparator接⼝的实现类；
为了省去定义⼀个ComparatorImpl实现类的⿇烦，不得不使⽤匿名内部类；
必须覆盖重写抽象compare⽅法，所以⽅法名称、⽅法参数、⽅法返回值不得不再写⼀遍，且不能写错；
实际上，只有参数和⽅法体才是关键。
Lambda写法
import java.util.Arrays;
public class Demo07ComparatorLambda {
public static void main(String[] args){
Person[] array ={
new Person("古⼒娜扎",19),
new Person("迪丽热巴",18),
new Person("马尔扎哈",20)};
Arrays.sort(array,(Person a, Person b)->{
Age()- b.getAge();
});
for(Person person : array){
System.out.println(person);
}
}
}
3.9 练习：使⽤Lambda标准格式（有参有返回）

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。