7.1. Lambda表达式

7.1.7. 练习

使用Lambda标准格式（无参无返回）

7.1.7.1. 题目

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

1
2
3
public interface Cook {
    void makeFood();
}

  在下面的代码中，请使用Lambda的标准格式调用invokeCook 方法，打印输出“吃饭啦！”字样：

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

7.1.7.2. 解答

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

备注：
  小括号代表Cook接口makeFood抽象方法的参数为空，大括号代表makeFood的方法体。

7.1.8. Lambda的参数和返回值

下面举例演示java.util.Comparator<T>接口的使用场景代码，其中的抽象方法定义为：

  • public abstract int compare(T o1, T o2);

  当需要对一个对象数组进行排序时， Arrays.sort方法需要一个Comparator接口实例来指定排序的规则。假设有一个Person类，含有String name和int age 两个成员变量：

1
2
3
4
5
public class Person {
    private String name;
    private int age;
    // 省略构造器、toString方法与Getter Setter
}

7.1.8.1. 传统写法

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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();
            }
        };
        // 第二个参数为排序规则，即Comparator接口实例
        Arrays.sort(array, comp); 
        for (Person person : array) {
            System.out.println(person);
        }
    }
}

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

代码分析

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

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

7.1.8.2. Lambda写法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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);
        }
    }
}

7.1.9. 练习：

使用Lambda标准格式（有参有返回）

7.1.9.1. 题目

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

1
2
3
public interface Calculator {
    int calc(int a, int b);
}

在下面的代码中，请使用Lambda的标准格式调用invokeCalc 方法，完成120和130的相加计算：

1
2
3
4
5
6
7
8
9
public class Demo08InvokeCalc {
    public static void main(String[] args) {
        // TODO 请在此使用Lambda【标准格式】调用invokeCalc方法来计算120+130的结果ß
    }
    private static void invokeCalc(int a, int b, Calculator calculator) {
        int result = calculator.calc(a, b);
        System.out.println("结果是：" + result);
    }
}

7.1.9.2. 解答

1
2
3
4
5
public static void main(String[] args) {
    invokeCalc(120, 130, (int a, int b) ‐> {
        return a + b;
    });
}

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

7.1.10. Lambda省略格式

7.1.10.1. 可推导即可省略

  Lambda强调的是“做什么”而不是“怎么做”，所以凡是可以根据上下文推导得知的信息，都可以省略。例如上例还可以使用Lambda的省略写法：

1
2
3
public static void main(String[] args) {
    invokeCalc(120, 130, (a, b) ‐> a + b);
}

7.1.10.2. 省略规则

在Lambda标准格式的基础上，使用省略写法的规则为：

  1. 小括号内参数的类型可以省略；
  2. 如果小括号内有且仅有一个参，则小括号可以省略；
  3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

备注：
  掌握这些省略规则后，请对应地回顾本章开头的多线程案例。

7.1.11. 练习：

使用Lambda省略格式

7.1.11.1. 题目

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

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

7.1.11.2. 解答

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

7.1.12 Lambda的使用前提

Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：

  1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
    无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
  2. 使用Lambda必须具有上下文推断。
    也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

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