Java 8新特性 - (1)Lambda表达式

Feb 25, 2021 java java 8 lambda

文章目录

为什么Java需要Lambda表达式?

在函数式编程语言中，函数是一等公民，它们可以独立存在，你可以将其赋值给一个变量，或将他们当做参数传给其他函数。JavaScript是最典型的函数式编程语言。函数式语言提供了一种强大的功能——闭包，相比于传统的编程方法有很多优势，闭包是一个可调用的对象，它记录了一些信息，这些信息来自于创建它的作用域。

Java现在提供的最接近闭包的概念便是Lambda表达式，虽然闭包与Lambda表达式之间存在显著差别，但至少Lambda表达式是闭包很好的替代者。

Lambda表达式为Java添加了缺失的函数式编程特点，它与闭包不同，但是又无限地接近闭包。在支持一类函数的语言中，Lambda 表达式的类型将是函数。但是，在Java中，Lambda表达式是对象，他们必须依附于一类特别的对象类型——函数式接口(functional interface)。

语法

Java中的Lambda表达式通常使用 (argument) -> (body) 语法书写，例如：

1(arg1, arg2...) -> { body }
2
3(type1 arg1, type2 arg2...) -> { body }

下面是一些例子:

1(int a, int b) -> {  return a + b; }
2
3() -> System.out.println("Hello World");
4
5(String s) -> { System.out.println(s); }
6
7() -> 42
8
9() -> { return 3.1415 };

Lambda表达式的结构:

一个 Lambda 表达式可以有零个或多个参数
参数的类型既可以明确声明，也可以根据上下文来推断。例如：(int a)与(a)效果相同
所有参数需包含在圆括号内，参数之间用逗号相隔。例如：(a, b) 或 (int a, int b) 或 (String a, int b, float c)
空圆括号代表参数集为空。例如：() -> 42
当只有一个参数，且其类型可推导时，圆括号（）可省略。例如：a -> return a*a
Lambda 表达式的主体可包含零条或多条语句
如果 Lambda 表达式的主体只有一条语句，花括号{}可省略。匿名函数的返回类型与该主体表达式一致
如果 Lambda 表达式的主体包含一条以上语句，则表达式必须包含在花括号{}中（形成代码块）。匿名函数的返回类型与代码块的返回类型一致，若没有返回则为空

函数式接口

在Java中，Marker（标记）类型的接口是一种没有方法或属性声明的接口，也就是空接口。相似地，函数式接口是只包含一个抽象方法声明的接口。比如java.lang.Runnable就是一种函数式接口，在Runnable接口中只声明了一个方法 void run()。

每个Lambda表达式都能隐式地赋值给函数式接口，例如，可以通过Lambda表达式创建 Runnable 接口的引用。

1Runnable r = () -> System.out.println("hello world");

当不指明函数式接口时，编译器会自动解释这种转化。下面的代码中，编译器会自动推断：根据线程类的构造函数签名 public Thread(Runnable r) { }，将该 Lambda 表达式赋给 Runnable 接口。

1new Thread(
2   () -> System.out.println("hello world")
3).start();

@FunctionalInterface 是 Java 8 新加入的一种接口，用于指明该接口类型声明是根据 Java 语言规范定义的函数式接口。Java 8 还声明了一些 Lambda 表达式可以使用的函数式接口，当你注释的接口不是有效的函数式接口时，可以使用 @FunctionalInterface 解决编译层面的错误。

以下是一种自定义的函数式接口：

1@FunctionalInterface public interface WorkerInterface {
2     public void doSomeWork();
3}

根据定义，函数式接口只能有一个抽象方法，如果你尝试添加第二个抽象方法，将抛出编译时错误。例如：

 1@FunctionalInterface
 2public interface WorkerInterface {
 3
 4    public void doSomeWork();
 5
 6    public void doSomeMoreWork();
 7
 8}
 9
10错误：
11
12Unexpected @FunctionalInterface annotation 
13    @FunctionalInterface ^ WorkerInterface is not a functional interface multiple 
14    non-overriding abstract methods found in interface WorkerInterface 1 error

变量作用域

Lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在Lambda内部修改定义在域外的局部变量，否则会编译错误。

 1public class Java8Tester {
 2 
 3   final static String salutation = "Hello! ";
 4   
 5   public static void main(String args[]){
 6      GreetingService greetService1 = message -> System.out.println(salutation + message);
 7      greetService1.sayMessage("Runoob");
 8   }
 9    
10   interface GreetingService {
11      void sayMessage(String message);
12   }
13}

以上代码输出结果为：

1Hello! Runoob

也可以直接在 Lambda 表达式中访问外层的局部变量：

 1public class Java8Tester {
 2    public static void main(String args[]) {
 3        final int num = 1;
 4        Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
 5        s.convert(2);  // 输出结果为 3
 6    }
 7 
 8    public interface Converter<T1, T2> {
 9        void convert(int i);
10    }
11}

Lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）

将上面代码修改一下：

 1public class Java8Tester {
 2    public static void main(String args[]) {
 3        int num = 1;  
 4        Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
 5        s.convert(2);
 6        num = 5; 
 7    }
 8 
 9    public interface Converter<T1, T2> {
10        void convert(int i);
11    }
12}

可以看到报错信息

1Local variable num defined in an enclosing scope must be final or effectively final

在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。

1String first = "";  
2Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length());  //编译会出错

表达式举例

线程

 1//旧方法:
 2new Thread(new Runnable() {
 3    @Override
 4    public void run() {
 5        System.out.println("Hello from thread");
 6    }
 7}).start();
 8
 9//新方法:
10new Thread(
11    () -> System.out.println("Hello from thread")
12).start();

事件处理

 1//旧方法
 2button.addActionListener(new ActionListener() {
 3    @Override
 4    public void actionPerformed(ActionEvent e) {
 5        System.out.println("The button was clicked using old fashion code!");
 6    }
 7});
 8
 9//新方法
10button.addActionListener( (e) -> {
11    System.out.println("The button was clicked. From Lambda expressions !");
12});

遍历元素

以下代码的作用是打印出给定数组中的所有元素。注意，使用 Lambda 表达式的方法不止一种。在下面的例子中，我们先是用常用的箭头语法创建 Lambda 表达式，之后，使用 Java 8 全新的双冒号(::)操作符将一个常规方法转化为 Lambda 表达式：

 1//Old way:
 2List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
 3for(Integer n: list) {
 4   System.out.println(n);
 5}
 6
 7//New way:
 8List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
 9list.forEach(n -> System.out.println(n));
10
11//or we can use :: double colon operator in Java 8
12list.forEach(System.out::println);

在下面的例子中，我们使用断言(Predicate)函数式接口创建一个测试，并打印所有通过测试的元素

 1import java.util.Arrays;
 2import java.util.List;
 3import java.util.function.Predicate;
 4
 5public class Main {
 6    public static void main(String [] a)  {
 7
 8        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
 9
10        System.out.println("Print all numbers:");
11        evaluate(list, (n)->true);
12
13        System.out.println("Print no numbers:");
14        evaluate(list, (n)->false);
15
16        System.out.println("Print even numbers:");
17        evaluate(list, (n)-> n%2 == 0 );
18
19        System.out.println("Print odd numbers:");
20        evaluate(list, (n)-> n%2 == 1 );
21
22        System.out.println("Print numbers greater than 5:");
23        evaluate(list, (n)-> n > 5 );
24    }
25
26    public static void evaluate(List<Integer> list, Predicate<Integer> predicate) {
27        for(Integer n: list)  {
28            if(predicate.test(n)) {
29                System.out.println(n + " ");
30            }
31        }
32    }
33}

输出

1Print all numbers: 1 2 3 4 5 6 7 
2Print no numbers: 
3Print even numbers: 2 4 6 
4Print odd numbers: 1 3 5 7 
5Print numbers greater than 5: 6 7

Lambda 表达式与匿名类的区别

使用匿名类与 Lambda 表达式的一大区别在于关键词的使用。对于匿名类，关键词 this 解读为匿名类，而对于 Lambda 表达式，关键词 this 解读为写就 Lambda 的外部类。

Lambda 表达式与匿名类的另一不同在于两者的编译方法。Java 编译器编译 Lambda 表达式并将他们转化为类里面的私有函数，它使用 Java 7 中新加的 invokedynamic 指令动态绑定该方法

参考：