提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  其它

当前栏目

第三章 Lambda表达式

表达式 lambda 第三章
2023-09-14 08:57:05 时间

第三章 Lambda表达式

3.1 函数式编程思想概述

　　在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做。
　　面向对象的思想:
　　　　做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.
　　函数式编程思想:
　　　　只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程

3.2 冗余的Runnable代码

传统写法
　　当需要启动一个线程去完成任务时，通常会通过java.lang.Runnable 接口来定义任务内容，并使用java.lang.Thread 类来启动该线程。代码如下：

 1 public class Demo01Runnable {
 2         public static void main(String[] args) {
 3             // 匿名内部类
 4             Runnable task = new Runnable() {
 5                 @Override
 6                 public void run() { // 覆盖重写抽象方法
 7                     System.out.println("多线程任务执行！");
 8                 }
 9             };
10             new Thread(task).start(); // 启动线程
11         }
12 }

本着“一切皆对象”的思想，这种做法是无可厚非的：首先创建一个Runnable 接口的匿名内部类对象来指定任务内容，再将其交给一个线程来启动。

代码分析

对于Runnable 的匿名内部类用法，可以分析出几点内容：

  • Thread 类需要Runnable 接口作为参数，其中的抽象run 方法是用来指定线程任务内容的核心；
  • 为了指定run 的方法体，不得不需要Runnable 接口的实现类；
  • 为了省去定义一个RunnableImpl 实现类的麻烦，不得不使用匿名内部类；
  • 必须覆盖重写抽象run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
  • 而实际上，似乎只有方法体才是关键所在。

3.3 编程思想转换

做什么，而不是怎么做　　

　　我们真的希望创建一个匿名内部类对象吗？不。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是：将run 方法体内的代码传递给Thread 类知晓。
　　传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。那有没有更加简单的办法？如果我们将关注点从“怎么做”回归到“做什么”的本质上，就会发现只要能够更好地达到目的，过程与形式其实并不重要。

3.4 体验Lambda的更优写法

借助Java 8的全新语法，上述Runnable 接口的匿名内部类写法可以通过更简单的Lambda表达式达到等效：

1 public class Demo02LambdaRunnable {
2         public static void main(String[] args) {
3             new Thread(() ‐ > System.out.println("多线程任务执行！")).start(); // 启动线程
4         }
5 }

　　这段代码和刚才的执行效果是完全一样的，可以在1.8或更高的编译级别下通过。从代码的语义中可以看出：我们启动了一个线程，而线程任务的内容以一种更加简洁的形式被指定。
　　不再有“不得不创建接口对象”的束缚，不再有“抽象方法覆盖重写”的负担，就是这么简单！

3.5 回顾匿名内部类

Lambda是怎样击败面向对象的？在上例中，核心代码其实只是如下所示的内容：

() ‐> System.out.println("多线程任务执行！")

为了理解Lambda的语义，我们需要从传统的代码起步。

使用实现类

要启动一个线程，需要创建一个Thread 类的对象并调用start 方法。而为了指定线程执行的内容，需要调用Thread 类的构造方法：

  • public Thread(Runnable target)

为了获取Runnable 接口的实现对象，可以为该接口定义一个实现类RunnableImpl ：

1     public class RunnableImpl implements Runnable {
2         @Override
3         public void run() {
4             System.out.println("多线程任务执行！");
5         }
6     }

然后创建该实现类的对象作为Thread 类的构造参数：

1     public class Demo03ThreadInitParam {
2         public static void main(String[] args) {
3             Runnable task = new RunnableImpl();
4             new Thread(task).start();
5         }
6     }

使用匿名内部类

这个RunnableImpl 类只是为了实现Runnable 接口而存在的，而且仅被使用了唯一一次，所以使用匿名内部类的语法即可省去该类的单独定义，即匿名内部类：

 1     public class Demo04ThreadNameless {
 2         public static void main(String[] args) {
 3             new Thread(new Runnable() {
 4                 @Override
 5                 public void run() {
 6                     System.out.println("多线程任务执行！");
 7                 }
 8             }).start();
 9         }
10     }

匿名内部类的好处与弊端

一方面，匿名内部类可以帮我们省去实现类的定义；另一方面，匿名内部类的语法——确实太复杂了！

语义分析

仔细分析该代码中的语义， Runnable 接口只有一个run 方法的定义：

  • public abstract void run();

即制定了一种做事情的方案（其实就是一个函数）：

  • 无参数：不需要任何条件即可执行该方案。
  • 无返回值：该方案不产生任何结果。
  • 代码块（方法体）：该方案的具体执行步骤。

同样的语义体现在Lambda 语法中，要更加简单：

() ‐> System.out.println("多线程任务执行！")
  • 前面的一对小括号即run 方法的参数（无），代表不需要任何条件；
  • 中间的一个箭头代表将前面的参数传递给后面的代码；
  • 后面的输出语句即业务逻辑代码。

3.6 Lambda标准格式

Lambda省去面向对象的条条框框，格式由3个部分组成：

  • 一些参数
  • 一个箭头
  • 一段代码

Lambda表达式的标准格式为：

(参数列表) -> {一些重写方法的代码};

解释说明格式:

  • ():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔
  • ->:传递的意思,把参数传递给方法体{}
  • {}:重写接口的抽象方法的方法体

代码示例：

 1 /*
 2     Lambda表达式的标准格式:
 3         由三部分组成:
 4             a.一些参数
 5             b.一个箭头
 6             c.一段代码
 7         格式:
 8             (参数列表) -> {一些重写方法的代码};
 9         解释说明格式:
10             ():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔
11             ->:传递的意思,把参数传递给方法体{}
12             {}:重写接口的抽象方法的方法体
13  */
14 public class Demo02Lambda {
15     public static void main(String[] args) {
16         //使用匿名内部类的方式,实现多线程
17         new Thread(new Runnable(){
18             @Override
19             public void run() {
20                 System.out.println(Thread.currentThread().getName()+" 新线程创建了");
21             }
22         }).start();
23 
24         //使用Lambda表达式,实现多线程
25         new Thread(()->{
26                 System.out.println(Thread.currentThread().getName()+" 新线程创建了");
27             }
28         ).start();
29 
30         //优化省略Lambda
31         new Thread(()->System.out.println(Thread.currentThread().getName()+" 新线程创建了")).start();
32     }
33 }

3.7 练习：使用Lambda标准格式（无参无返回）

题目
给定一个厨子Cook 接口，内含唯一的抽象方法makeFood ，且无参数、无返回值

Cook.java：

1 /*
2     定一个厨子Cook接口，内含唯一的抽象方法makeFood
3  */
4 public interface Cook {
5     //定义无参数无返回值的方法makeFood
6     public abstract void makeFood();
7 }

Demo01Cook.java：

 1 /*
 2     需求:
 3         给定一个厨子Cook接口，内含唯一的抽象方法makeFood，且无参数、无返回值。
 4         使用Lambda的标准格式调用invokeCook方法，打印输出“吃饭啦！”字样
 5  */
 6 public class Demo01Cook {
 7     public static void main(String[] args) {
 8         //调用invokeCook方法,参数是Cook接口,传递Cook接口的匿名内部类对象
 9         invokeCook(new Cook() {
10             @Override
11             public void makeFood() {
12                 System.out.println("吃饭了");
13             }
14         });
15 
16         //使用Lambda表达式,简化匿名内部类的书写
17         invokeCook(()->{
18             System.out.println("吃饭了");
19 });
20 
21         //优化省略Lambda
22         invokeCook(()-> System.out.println("吃饭了"));
23     }
24 
25     //定义一个方法,参数传递Cook接口,方法内部调用Cook接口中的方法makeFood
26     public static void invokeCook(Cook cook){
27         cook.makeFood();
28     }
29 }

备注：小括号代表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：

 1 public class Person {
 2     private String name;
 3     private int age;
 4 
 5     public Person() {
 6     }
 7 
 8     public Person(String name, int age) {
 9         this.name = name;
10         this.age = age;
11     }
12 
13     @Override
14     public String toString() {
15         return "Person{" +
16                 "name='" + name + '\'' +
17                 ", age=" + age +
18                 '}';
19     }
20 
21     public String getName() {
22         return name;
23     }
24 
25     public void setName(String name) {
26         this.name = name;
27     }
28 
29     public int getAge() {
30         return age;
31     }
32 
33     public void setAge(int age) {
34         this.age = age;
35     }
36 }

传统写法
如果使用传统的代码对Person[] 数组进行排序，写法如下：

 1 import java.util.Arrays;
 2 import java.util.Comparator;
 3 
 4 public class Demo06Comparator {
 5     public static void main(String[] args) {
 6 // 本来年龄乱序的对象数组
 7         Person[] array = {
 8                 new Person("古力娜扎", 19),
 9                 new Person("迪丽热巴", 18),
10                 new Person("马尔扎哈", 20)};
11 // 匿名内部类
12         Comparator<Person> comp = new Comparator<Person>() {
13             @Override
14             public int compare(Person o1, Person o2) {
15                 return o1.getAge() ‐o2.getAge();
16             }
17         };
18         Arrays.sort(array, comp); // 第二个参数为排序规则，即Comparator接口实例
19         for (Person person : array) {
20             System.out.println(person);
21         }
22     }
23 }

这种做法在面向对象的思想中，似乎也是“理所当然”的。其中Comparator 接口的实例（使用了匿名内部类）代表了“按照年龄从小到大”的排序规则。

代码分析

下面我们来搞清楚上述代码真正要做什么事情。

  • 为了排序， Arrays.sort 方法需要排序规则，即Comparator 接口的实例，抽象方法compare 是关键；
  • 为了指定compare 的方法体，不得不需要Comparator 接口的实现类；
  • 为了省去定义一个ComparatorImpl 实现类的麻烦，不得不使用匿名内部类；
  • 必须覆盖重写抽象compare 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
  • 实际上，只有参数和方法体才是关键。

Lambda写法

 1 import java.util.Arrays;
 2 
 3 public class Demo07ComparatorLambda {
 4     public static void main(String[] args) {
 5         Person[] array = {
 6                 new Person("古力娜扎", 19),
 7                 new Person("迪丽热巴", 18),
 8                 new Person("马尔扎哈", 20)};
 9         Arrays.sort(array, (Person a, Person b) ‐>{
10             return a.getAge() ‐b.getAge();
11         });
12         for (Person person : array) {
13             System.out.println(person);
14         }
15     }
16 }

3.9 练习：使用Lambda标准格式（有参有返回）

题目
给定一个计算器Calculator 接口，内含抽象方法calc 可以将两个int数字相加得到和值：

Calculator.java：

1 /*
2     给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
3  */
4 public interface Calculator {
5     //定义一个计算两个int整数和的方法并返回结果
6     public abstract int calc(int a,int b);
7 }

Demo01Calculator.java：

 1 /*
 2     Lambda表达式有参数有返回值的练习
 3     需求:
 4         给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
 5         使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算
 6  */
 7 public class Demo01Calculator {
 8     public static void main(String[] args) {
 9         //调用invokeCalc方法,方法的参数是一个接口,可以使用匿名内部类
10         invokeCalc(10, 20, new Calculator() {
11             @Override
12             public int calc(int a, int b) {
13                 return a+b;
14             }
15         });
16 
17         //使用Lambda表达式简化匿名内部类的书写
18         invokeCalc(120,130,(int a,int b)->{
19             return a + b;
20 });
21 
22         //优化省略Lambda
23         invokeCalc(120,130,(a,b)-> a + b);
24     }
25 
26     /*
27         定义一个方法
28         参数传递两个int类型的整数
29         参数传递Calculator接口
30         方法内部调用Calculator中的方法calc计算两个整数的和
31      */
32     public static void invokeCalc(int a,int b,Calculator c){
33         int sum = c.calc(a,b);
34         System.out.println(sum);
35     }
36 }

备注：小括号代表Calculator 接口calc 抽象方法的参数，大括号代表calc 的方法体。

3.10 Lambda省略格式

Lambda表达式:是可推导,可以省略
凡是根据上下文推导出来的内容,都可以省略书写
可以省略的内容:

  1. (参数列表):括号中参数列表的数据类型,可以省略不写
  2. (参数列表):括号中的参数如果只有一个,那么类型和()都可以省略
  3. {一些代码}:如果{}中的代码只有一行,无论是否有返回值,都可以省略({},return,分号)

注意:要省略{},return,分号必须一起省略

补充：

1 public class Demo01ArrayList {
2     public static void main(String[] args) {
3         //JDK1.7版本之前,创建集合对象必须把前后的泛型都写上
4         ArrayList<String> list01 = new ArrayList<String>();
5 
6         //JDK1.7版本之后,=号后边的泛型可以省略,后边的泛型可以根据前边的泛型推导出来
7         ArrayList<String> list02 = new ArrayList<>();
8     }
9 }

3.11 练习：使用Lambda省略格式

题目
仍然使用前文含有唯一makeFood 抽象方法的厨子Cook 接口，在下面的代码中，请使用Lambda的省略格式调用invokeCook 方法，打印输出“吃饭啦！”字样：

1     public class Demo09InvokeCook {
2         public static void main(String[] args) {
3             // TODO 请在此使用Lambda【省略格式】调用invokeCook方法
4         }
5         private static void invokeCook(Cook cook) {
6             cook.makeFood();
7         }
8     }

解答

1     public static void main(String[] args) {
2         invokeCook(() ‐ > System.out.println("吃饭啦！"));
3     }

3.12 Lambda的使用前提

Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：
　　1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
　　　　无论是JDK内置的Runnable 、Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
　　2. 使用Lambda必须具有上下文推断。
　　　　也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

备注：有且仅有一个抽象方法的接口，称为“函数式接口”。

相关文章