正文
第三章 Lambda表达式
小程序：扫一扫查出行【扫一扫了解最新限行尾号】
复制小程序
第三章 Lambda表达式
3.1 函数式编程思想概述
在数学中，
函数
就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做。
面向对象的思想:
做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.
函数式编程思想:
只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程
3.2 冗余的Runnable代码
传统写法
当需要启动一个线程去完成任务时，通常会通过java.lang.Runnable 接口来定义任务内容，并使用java.lang.Thread 类来启动该线程。代码如下：
public class Demo01Runnable {
public static void main(String[] args) {
// 匿名内部类
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 类知晓。
传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。那有没有更加简单的办法？如果我们将关注点从“怎么做”回归到“做什么”的本质上，就会发现只要能够更好地达到目的，过程与形式其实并不重要。
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表达式的 标准格式 为：
(参数列表) -> {一些重写方法的代码};
解释说明格式:
- ():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔
- ->:传递的意思,把参数传递给方法体{}
- {}:重写接口的抽象方法的方法体
代码示例：
/*
Lambda表达式的标准格式:
由三部分组成:
a.一些参数
b.一个箭头
c.一段代码
格式:
(参数列表) -> {一些重写方法的代码};
解释说明格式:
():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔
->:传递的意思,把参数传递给方法体{}
{}:重写接口的抽象方法的方法体
*/
public class Demo02Lambda {
public static void main(String[] args) {
//使用匿名内部类的方式,实现多线程
new Thread(new Runnable(){
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+" 新线程创建了");
}
}).start(); //使用Lambda表达式,实现多线程
new Thread(()->{
System.out.println(Thread.currentThread().getName()+" 新线程创建了");
}
).start(); //优化省略Lambda
new Thread(()->System.out.println(Thread.currentThread().getName()+" 新线程创建了")).start();
}
}
3.7 练习：使用Lambda标准格式（无参无返回）
题目
给定一个厨子Cook 接口，内含唯一的抽象方法makeFood ，且无参数、无返回值
Cook.java：
/*
定一个厨子Cook接口，内含唯一的抽象方法makeFood
*/
public interface Cook {
//定义无参数无返回值的方法makeFood
public abstract void makeFood();
}
Demo01Cook.java：
/*
需求:
给定一个厨子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("吃饭了");
}); //优化省略Lambda
invokeCook(()-> System.out.println("吃饭了"));
} //定义一个方法,参数传递Cook接口,方法内部调用Cook接口中的方法makeFood
public static void invokeCook(Cook cook){
cook.makeFood();
}
}
备注：小括号代表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 两个成员变量：
Person.java：
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
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;
}
}
传统写法
如果使用传统的代码对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) {
return o1.getAge() ‐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) ‐>{
return a.getAge() ‐b.getAge();
});
for (Person person : array) {
System.out.println(person);
}
}
}
3.9 练习：使用Lambda标准格式（有参有返回）
题目
给定一个计算器Calculator 接口，内含抽象方法calc 可以将两个int数字相加得到和值：
Calculator.java：
/*
给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
*/
public interface Calculator {
//定义一个计算两个int整数和的方法并返回结果
public abstract int calc(int a,int b);
}
Demo01Calculator.java：
/*
Lambda表达式有参数有返回值的练习
需求:
给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算
*/
public class Demo01Calculator {
public static void main(String[] args) {
//调用invokeCalc方法,方法的参数是一个接口,可以使用匿名内部类
invokeCalc(10, 20, new Calculator() {
@Override
public int calc(int a, int b) {
return a+b;
}
}); //使用Lambda表达式简化匿名内部类的书写
invokeCalc(120,130,(int a,int b)->{
return a + b;
20 }); //优化省略Lambda
invokeCalc(120,130,(a,b)-> 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);
}
}
备注：小括号代表Calculator 接口calc 抽象方法的参数，大括号代表calc 的方法体。
3.10 Lambda省略格式
Lambda表达式:是可推导,可以省略
凡是根据上下文推导出来的内容,都可以省略书写
可以省略的内容:
- (参数列表):括号中参数列表的数据类型,可以省略不写
- (参数列表):括号中的参数如果只有一个,那么类型和()都可以省略
- {一些代码}:如果{}中的代码只有一行,无论是否有返回值,都可以省略({},return,分号)
注意:要省略{},return,分号必须一起省略
补充：
public class Demo01ArrayList {
public static void main(String[] args) {
//JDK1.7版本之前,创建集合对象必须把前后的泛型都写上
ArrayList<String> list01 = new ArrayList<String>();
//JDK1.7版本之后,=号后边的泛型可以省略,后边的泛型可以根据前边的泛型推导出来
ArrayList<String> list02 = new ArrayList<>();
}
}
3.11 练习：使用Lambda省略格式
题目
仍然使用前文含有唯一makeFood 抽象方法的厨子Cook 接口，在下面的代码中，请使用Lambda的省略格式调用invokeCook 方法，打印输出“吃饭啦！”字样：
public class Demo09InvokeCook {
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("吃饭啦！"));
}
3.12 Lambda的使用前提
Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：
1. 使用Lambda必须具有接口，且要求
接口中有且仅有一个抽象方法
。
无论是JDK内置的Runnable 、Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
2. 使用Lambda必须具有
上下文推断
。
也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
备注：有且仅有一个抽象方法的接口，称为“函数式接口”。
