Java 8 导入了一个新型态的语法──Lambda。然而这个 Lambda 语法并不是新的语法,在 Script Languages 和 Functional Languages 中都可以常常见到,为什么 Java 8 要特地导入 Lambda 呢?难道先前的那些语法没办法完成什么特别的功能吗?这问题待文章之后解答,我们先来看看什么是 Lambda。

什么是 Lambda?

Lambda 通用定义

在不同领域,对于 Lambda 的定义可能不太相同,但概念都是 Lambda 为一个函数,可以根据输入的值,决定输出的值。但 Lambda 与一般函数不同的是,Lambda 并不需要替函数命名(如 F(X) = X + 2、G(X) = F(X) + 3 中的 F、G 便是函数的名称),所以我们常常把 Lambda 形容为「匿名的」(Anonymous)。

匿名类别(Anonymous class)

在 Java 中,匿名类别是非常常见的对象实体化方式,相信学过 Java 的人都有用过类似以下的方式去实体化一个对象出来:

class ClassA {

}

public class MainClass {

    public static void main(String[] args) {
        ClassA a = new ClassA() { //实体化匿名类别
            public void function1(int x, int y) {
                System.out.println(x + y);
            }

            public int function2(int x) {
                return x + 1;
            }
        };
    }
}
以上是将匿名类别实体化出来的一段程序。为何说代码内的 ClassA 是匿名的呢?其实匿名类别指的不是 ClassA(ClassA 已有 ClassA 这个名称,自然不会是一个匿名类别),而是在 new 的同时,被重新修改过的 ClassA(在 new statement 之后加上大括号 {},就判定为重新修改)。这样说可能还是很模糊,如果对照以下非匿名类别的撰写方式,就可以清楚匿名和非匿名的差异了。

class ClassA {

}

class ClassB extends ClassA { //在另外的地方声明class,并且继承或是实作ClassA

    public void function1(int x, int y) {

    }

    public int function2(int x) {
        return x + 1;
    }
}

public class MainClass {

    public static void main(String[] args) {
        ClassA a = new ClassB();
    }
}

将原先使用的匿名类别,另外声明成一个 ClassB 出来,调用时直接 new ClassB,此处的类别便不是匿名类别,而相比每次只能够在同一个代码位置 new 出实体的匿名类别,ClassB 则可以在任何 Scope 所及的地方 new 出实体。

我们都知道,Java 会把每个类别在编译时期,都创建出相对应的 .class 文件。如果是一般的类别,则会直接以 Class 的名称作为 .class 文件的文件名。如果是内部(Inner)的非匿名类别,则会以 $ 为分隔字符,表示类别在哪层类别之下,作为 .class 文件的文件名。举例,编译出以下的程序,会得到 A.class 与 A$B.class 两个文件。

class A {

    class B {

    }
}

但如果有内部的匿名类别,那 .class 会如何产生呢?无论匿名类别是从何种类别重新修改而来,Java 都会按照匿名类别是在哪层底下,给予流水的数字编号。举例,编译出以下的程序,会得到 C.class、A.class、A$B.class、A$1.class 与 A$2.class 五个文件。

class C {

}

class A {

    class B {

    }

    public void f2() {
        C c = new C() {

        };
    }

    public void f1() {
        B c = new B() {

        };
    }
}

由此可知,匿名类别实际上也拥有一个 .class 文件,在概念上,它其实就是将一个类别或是界面在编译 new statement 时由编译器重新产生出另一个类别。

Java 的 Lambda

在 Java 8 之后,导入了 Lambda 语法,或者可以称为 Lambda 表达式。如果说 Lambda 语法是用来表示一个匿名类别的话,那就不太正确了。实际上 Lambda 语法只能用来表示一个「只拥有一个方法的界面」所实作出来的匿名类别,但这样讲也是不太正确,在文章之后会进行观念的改正,现在姑且先将其认知成这样。

「只拥有一个方法的界面」在 Java 中很常使用到,例如线程的 Runnable 界面只拥有一个 run 方法,或是 AWT 的 ActionListener 只拥有一个 actionPerformed 方法。这类界面,都可以直接使用 Lambda,将它们拥有的那单个方法快速实作出来。在 Java 8 之前,我们将这类的界面称为 Single Abstract Method type(SAM);在 Java 8 之后,因为这类的界面变得十分重要,所以将其另称为 Functional Interface。

Lambda 语法结构

input -> body

其中,input 和 body 都各有多种撰写方式,以下分别举例。

input

不输入

()

单个输入

x

多个输入(不省略型态)

(int x,int y)

多个输入(省略型态)

(x,y)
body

什么都不做

{}

单行不回传值

System.out.println("NO");

多行不回传值

{
    System.out.println("NO");
    System.out.println("NO2");
}

单行回传值

x+y

多行回传值

{
    x++;
    y-=x;
    return x+y;
}

以上几种方式,可以自己练习组合看看。另外还有一种特殊语法结构,可以省略掉 input 和 ->,因为会使代码较不易阅读,不建议使用,将在文章最后提到。

Lambda 实际应用与性能比较

取代 Functional Interface 产出的匿名类别

在 Java 中,许多只有一个方法的界面,如果要使用这些界面,往往需要使用到至少 4 进程式码才有办法达成,举例:

Runnable runnbale = new Runnable() {
    public void run() {
        System.out.println("run me!");
    }
};

这样的使用方式,往往会让 Java 程序拉得很长,变得十分复杂。因此 Lambda 最重要的功能,就是取代 Functional Interface 所产出的匿名类别,简化代码,甚至还可以提升性能(稍后提到)。举例,同样的 Runnable 使用方式,可以简化成:

Runnable runnbale = () -> System.out.println("run me!");

使用 Lambda 来取代以往 Functional Interface 的使用方式,可以大大的缩短代码,在编译的过程中,也可以避免掉产生新的 .class 文件出来,运行的时候,则是在第一次运行到 Lambda 时才动态产生实作该界面的类别,再由它去调用 Lambda 的 body 被编译成的私有方法。没有用到外部变量和 this 的 Lambda,通常还会重复使用同一个对象实体,不必每次都重新 new 出一个对象实体,因此可以提升程序的运行性能。

如果有兴趣知道 Lambda 是如何运作,可以查看编译出来 .class 文件的 bytecode,查看命令如下:

javap -c Class路径

举例:

javap -c org.magiclen.A

比较原先不使用 Lambda,与使用 Lambda 的方式:

不使用 Lambda

0: new #2
3: dup
4: invokespecial #3

使用 Lambda

0: invokedynamic #2, 0

可以发现使用 Lambda 就连 bytecode,都可以从三行命令,缩减成一行命令。invokedynamic 就是动态调用内存内的某段代码。

此外,Lambda 的 body 不会像匿名类别那样有自己的 this,Lambda 中的 this 指的就是 Lambda 所在的对象,因此会有以下这个现象发生:

Runnable r1 = () -> System.out.println("r1: " + this.getClass());
	
Runnable r2 = new Runnable(){
    public void run(){
        System.out.println("r2: " + this.getClass());
    }
};

new Thread(r1).start();
new Thread(r2).start();

虽然两个线程都是调用 this.getClass(),但 print 出来的结果却不一样。而且可以知道使用 Lambda 的 r1,this 所指的对象就是此行 Lambda 语法所在的对象,并不会像没使用 Lambda 的 r2 一样变成一个匿名类别的对象。

Lambda 与 Collection 的关系

Lambda 除了用来取代以往使用 Functional Interface 的方式外,还可以用在 Collection 的走访、过滤和一些简单的运算上。而且同样地,使用 Lambda 可以增加不少的性能。

走访

过去我们使用 For each 走访一个 List 可能要写成这样:

for (String s : list) {
    System.out.print(s);
}

如果要走访一个 Map 更麻烦,可能要写成这样:

Set<String> keySet = map.keySet();
for (String s : keySet) {
	System.out.print(s + ":" + map.get(s));
}

若改以 Lambda 来走访这些 Collection,可以简化成这样:

list.forEach(s -> System.out.print(s));
map.forEach((k, v) -> System.out.print(k + ":" + v));

代码精简许多,因为少了循环,就连 bytecode 也能将原先十几行指令省略到剩下三行。

过滤和基本运算

在新的 Java 8 中,Collection 提供了 stream() 方法,可以对集合做一些过滤和基本运算,而且这个当然也是有经过性能优化过的。除了 stream() 方法外还有 parallelStream() 方法,可以将 Collection 的元素切分成好几块,交给共用的 ForkJoinPool 线程池中的多个 Thread 平行处理,进行 stream 提供的运算,让多核心的 CPU 资源更能有效的被利用。以下将举几个过滤和基本运算的例子:

List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
list.add("3");
list.add("5");
list.add("4");
list.stream().filter(s -> Integer.valueOf(s) < 3).forEach(s -> System.out.print(s));

以上会输出 12。

List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
list.add("3");
list.add("5");
list.add("4");
List<String> list2 = list.stream().filter(s -> Integer.valueOf(s) < 3).collect(Collectors.toList());
list2.add("7");
list2.forEach(s -> System.out.print(s));

以上会输出 127。

List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
list.add("3");
list.add("5");
list.add("4");
System.out.println(list.stream().mapToInt(s->Integer.valueOf(s)).sum());
System.out.println(list.stream().filter(s -> Integer.valueOf(s) < 3).mapToInt(s->Integer.valueOf(s)).average().getAsDouble());

以上会输出

15
1.5

Lambda 特殊精简语法结构

除了前面介绍到的 input -> body 结构,Lambda 在某些特定的场合下,还能够写出更短的语法,结构如下:

方法名称

什么!?只要写方法名称就好了吗?甚至连参数也不用传!是的,Lambda 允许这种类型的语法存在,但必须要明确指定方法名称是在哪个类别或是哪个对象之下,而且最后一个 . 要改成 ::。这样说好像很模糊,举几个例子好了:

interface B {

    public void doStringWork(String s);
}

interface C {

    public double doComputeWork(float x, float y);
}

public class A {

    public A() {
        B b = this::printOnce;
        b.doStringWork("哈啰");
    }

    public static void main(String[] args) {
        B b = A::printTwice;
        b.doStringWork("嗨");
        new A();

        C c = Math::pow;
        b.doStringWork(String.valueOf(c.doComputeWork(2.5f, 2)));
    }

    public static void printTwice(String s) {
        System.out.print(s);
        System.out.println(s);
    }

    public void printOnce(String s) {
        System.out.println(s);
    }
}

以上输出结果为:

嗨嗨
哈啰
6.256.25

这样的结构虽然可以使得程序变得非常精简,却也不易阅读。这种撰写方式,实际上常与 forEach 搭配,如下:

List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
list.add("3");
list.add("5");
list.add("4");
list.forEach(System.out::print);

以上程序会输出 12354。

总结

Java 8 依靠 Lambda 新语法,简化程序,改善性能,在结构上浅显易懂、容易使用,实属不错的新功能!