初探 Java8 新特性之 lambda 表达式

Posted on In Word count in article: 1.2k Reading time ≈ 4 mins.

Java8 带有 Lambda 表达式的预览版的 JDK 已经放出来了（地址在最下面），新特性有以下四个：

  1. Lambda 表达式（或称之为 “闭包” 或者 “匿名函数”）

  2. 扩展的目标类型

  3. 方法和构造器引用

  4. 接口默认方法

本文先介绍一下 Java8 中很值得期待的 Lambda 表达式，Lambda 表达式，等同于大多说动态语言中常见的闭包、匿名函数的概念。其实这个概念并不是多么新鲜的技术，在 C 语言中的概念类似于一个函数指针，这个指针可以作为一个参数传递到另外一个函数中。由于 Java 是相对较为面向对象的语言，一个 Java 对象中可以包含属性和方法（函数），方法（函数）不能孤立于对象单独存在。这样就产生了一个问题，有时候需要把一个方法（函数）作为参数传到另外一个方法中的时候（比如回调功能），就需要创建一个包含这个方法的接口，传递的时候传递这个接口的实现类，一般是用匿名内部类的方式来。如下面代码，首先创建一个 Runnable 的接口，在构造 Thread 时，创建一个 Runnable 的匿名内部类作为参数：

1
2
3
4
5
new Thread(new Runnable() {  
    public void run() {  
        System.out.println("hello");  
    }  
}).start();

类似这种情况的还有 swing 中 button 等控件的监听器，如下面代码所示，创建该接口的一个匿名内部类实例作为参数传递到 button 的 addActionListener 方法中。

1
2
3
4
5
6
7
8
9
public interface ActionListener {   
    void actionPerformed(ActionEvent e);  
}  

button.addActionListener(new ActionListener() {   
  public void actionPerformed(ActionEvent e) {   
    ui.dazzle(e.getModifiers());  
  }  
});

这样的代码的缺点是有代码笨重，可读性差，不能引用外面的非 final 的变量等。lambda 表达式就是为了解决这类问题而诞生的。

在介绍 Java8 中的 Lambda 表达式之前，首先介绍一个概念叫 “函数式接口”（functional interfaces）。对于任意一个 Java 接口，如果接口中只定义了唯一一个方法，那么这个接口就称之为 “函数式接口”。比如 JDK 中的 ActionListener、Runnable、Comparator 等接口。

先来看一下 Java8 中的 lambda 表达式的使用示例：

创建一个线程：

1
new Thread(() -> {System.out.println("hello");}).start();

可以看到这段代码比上面创建线程的代码精简了很多，也有很好的可读性。
() -> {System.out.println(“hello”);} 就是传说中的 lambda 表达式，等同于上面的 new Runnable(),lambda 大体分为 3 部分：

1. 最前面的部分是一对括号，里面是参数，这里无参数，就是一对空括号

2. 中间的是 -> ，用来分割参数和 body 部分

3. 是 body 部分，可以是一个表达式或者一个语句块。如果是一个表达式，表达式的值会被作为返回值返回；如果是语句块，需要用 return 语句指定返回值。如下面这个 lambda 表达式接受一个整形的参数 a，返回 a 的平方

1
2
3
(int a) -> a^2   
//等同于
(int a) -> {return a^2;}

继续看更多的例子：

1
2
3
4
5
(int x, int y) -> x + y  

() -> 42  

(String s) -> { System.out.println(s); }

创建一个 FileFilter，文件过滤器：

1
FileFilter java = (File f) -> f.getName().endsWith(".java")

创建一个线程：

1
2
3
new Thread(() -> {  
  //do sth here...  
}).start()

创建一个 Callable：

1
Callable<String> c = () -> "done";

而且 lambda 表达式可以赋值给一个变量：

1
2
Comparator<String> c;  
c = (String s1, String s2) -> s1.compareToIgnoreCase(s2);

当然还可以作为方法的返回值：

1
2
3
4
5
public Runnable toDoLater() {  
  return () -> {  
    System.out.println("later");  
  };  
}

从上面可以看到，一个 lambda 表达式被作为一个接口类型对待，具体对应哪个接口，编译器会根据上下文环境推断出来，如下面的 lambda 表达式就表示一个 ActionListener.

1
ActionListener l = (ActionEvent e) -> ui.dazzle(e.getModifiers());

这有可能会造成一个表达式在不同的上下文中被作为不同的类型，如下面的这种情况，尽管两个表达式是相同的，上面的表达式被推断为 Callable 的类型，下面的会被推断为 PrivilegedAction 类型。

1
2
Callable<String> c = () -> "done";  
PrivilegedAction<String> a = () -> "done";

那么编译器是根据哪些因为决定一个表达式的类型呢？

如果一个表达式被推断为是 T 类型的，需要满足以下 4 个条件:

  1. T 是函数式接口类型（只声明唯一一个方法）
  2. 表达式和 T 中声明的方法的参数个数一致，参数类型也一致
  3. 表达式和 T 中声明的方法的返回值类型一致
  4. 表达式和 T 中声明的方法抛出的异常一致
    有了这个准则，上面的疑问就迎刃而解了

参考：

1.State of the Lambda

2.Java8 带有 Lambda 表达式版本的 JDK 下载地址