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,查看命令如下:
举例:
比较原先不使用 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());
以上会输出
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 新语法,简化程序,改善性能,在结构上浅显易懂、容易使用,实属不错的新功能!
