为什么使用Lambda表达式
第一个例子，在一个独立的线程中执行某项任务，我们通常这么实现：
?
1
2
3
4
5
6
7
8
9
10
class Worker implements Runnable {
public void run() {
for (int i = 0; i < 100; i++)
doWork();
}
...
}
Worker w = new Worker();
new Thread(w).start();
第二个例子，自定义字符串比较的方法（通过字符串长度），一般这么做：
?
1
2
3
4
5
6
class LengthComparator implements Comparator {
public int compare(String first, String second) {
return Integer.compare(first.length(), second.length());
}
}
Arrays.sort(strings, new LengthComparator());
第三个例子，在JavaFX中，给一个button添加一个callback：
?
1
2
3
4
5
button.setOnAction(new EventHandler() {
public void handle(ActionEvent event) {
System.out.println("Thanks for clicking!");
}
});
这些例子有一个共同点，就是：先定义一段代码块，传给某个对象或方法，然后被执行。在Lambda表
Lambda表达式的语法
?
1
2
(String first, String second) -> Integer.compare(first.length(),
second.length());
->前为参数列表，其后为表达式语句体；
如果表达式语句体不止一行，则将语句体写在{}中，与普通的函数一样：
?
1
2
3
4
5
6
7
8
9
(String first, String second) -> {
if (first.length() > second.length()) {
return 1;
} else if (first.length() == second.length()) {
return 0;
} else {
return -1;
}
};
如果没有参数，()还是需要带上，比如上面的第一个例子，可以表示为：
?
1
2
3
4
5
() -> {
for (int i = 0; i < 1000; i ++) {
doWork();
}
}
如果参数的类型可以从上下文自动推断，则可以省略：
?
1
2
3
Comparator comp
= (first, second) // Same as (String first, String second)
-> Integer.compare(first.length(), second.length());
如果参数只有一个，且类型可以自动推断，则小括号()也可以省略：
?
1
2
3
// Instead of (event) -> or (ActionEvent event) ->
eventHandler listener =
event -> System.out.println("Thanks for clicking!");
lambda表达式的返回值的类型是自动推断的，因此不需要指明；在lambda表达式，某些条件分支中有
?
1
2
3
4
5
(x) -> {
if (x >= 0) {
return 1;
}
}
另外，expression lambda和statement lambda的区别是，expression lambda不需要
?
1
2
3
4
5
6
7
// expression lambda
Comparator comp1 =
(first, second) -> Integer.compare(first.length(), second.length());
// statement lambda
Comparator comp2 = (first, second) ->
{ return Integer.compare(first.length(), second.length());};
Functional Interface
?
1
2
Arrays.sort(words,
(first, second) -> Integer.compare(first.length(), second.length()));
这里，sort()的第二个参数需要的是一个Comparator对象，而Comparator是
如果lambda表达式的语句体会抛出异常，则对应的Functional Interface中的抽象方法必须抛
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Runnable r = () -> {
System.out.println("------");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// catch exception
}
};
Callable c = () -> {
System.out.println("--------");
Thread.sleep(10);
return "";
};
Method Reference
?
1
2
(x) -> System.out.println(x)
System.out::println
其中System.out::println被称为Method Reference。
Method Reference主要有三种形式：
object::instanceMethod
Class::staticMethod
Class::instanceMethod
对于前两种方式，对应的lambda表达式的参数和method的参数是一致的，比如：
?
1
2
3
4
5
System.out::println
(x) -> System.out.println(x)
Math::pow
(x, y) -> Math.pow(x, y)
对于第三种方式，对应的lambda表达式的语句体中，第一个参数作为对象，调用method，将其它参数
?
1
2
3
String::compareToIgnoreCase
(s1, s2) -> s1.compareToIgnoreCase(s2)
1.5 Constructor Reference
Constructor Reference与Method Reference类似，只不过是特殊的method：new，具体调用的是哪个构造函数，由上下文环境决定，比如：
?
1
2
List labels = ...;
Stream stream = labels.stream().map(Button:: new);
Button::new等价于(x) -> Button(x)，所以调用的构造函数是：Button(x);
除了创建单个对象，也可以创建对象数组，如下面两种方式等价：
?
1
2
int[]::new
(x) -> new int[x]
变量作用域
?
1
2
3
4
5
6
7
8
9
public void repeatMessage(String text, int count) {
Runnable r = () -> {
for (int i = 0; i < count; i ++) {
System.out.println(text);
Thread.yield();
}
};
new Thread(r).start();
}
但是这些变量必须是不可变的，为什么呢？看下面这个例子：
?
1
2
3
4
int matches = 0;
for (Path p : files)
new Thread(() -> { if (p has some property) matches++; }).start();
// Illegal to mutate matches
因为可变的变量在lambda表达式中不是线程安全的，这和内部类的要求是一致的，内部类中只能引用
lambda表达式的作用域与嵌套代码块的作用域是一样的，所以在lambd表达式中的参数名或变量名不
?
1
2
3
Path first = Paths.get("/usr/bin");
Comparator comp = (first, second) -> Integer.compare(first.length(),
second.length()); // Error: Variable first already defined
如果在lambda表达式中引用this变量，则引用的是创建该lambda表达式的方法的this变量，如：
?
1
2
3
4
5
6
7
8
9
public class Application() {
public void doWork() {
Runnable runner = () -> {
...;
System.out.println(this.toString());
...
};
}
}
所以这里的this.toString()调用的是Application对象的toString()，而不是Runnable
Default Method
?
1
2
3
4
interface Person {
long getId();
default String getName() { return "John Q. Public"; }
}
Java是允许多继承的，如果一个类的父类中定义的方法和接口中定义的default方法完全相同，或者
如果是父类和接口的方法冲突：以父类中的方法为准，接口中的方法被忽略；
Static Method
?
1
2
3
4
5
6
7
public static Comparator comparingInt(ToIntFunctionsuper T>
keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (Comparator & Serializable)
(c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1),
keyExtractor.applyAsInt(c2));
}
使用这个static方法，以下两种方式也是等价的：
1、
?
1
2
Arrays.sort(cities, (first, second) -> Integer.compare(first.length(),
second.length()));
2、
?
1
Arrays.sort(cities, Comparator.comparingInt(String::length));
所以，以后我们在设计自己的接口时，不需要再定义单独的工具类（如Collections/Collection)，
匿名内部类
在 Java 世界中，匿名内部类 可以实现在应用程序中可能只执行一次的操作。例如，在 Android 应用程序中，一个按钮的点击事件处理。你不需要为了处理一个点击事件单独编写一个独立的类，可以用匿名内部类完成该操作：
?
1
2
3
4
5
6
7
8
9
Button button = (Button) findViewById(R.id.button1);
button.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
Toast.makeText(MainActivity.this, "Button Clicked", Toast.LENGTH_SHORT).show();
}
});
Lambda 示例
1.Runnable Lambda
来看几个示例， 下面是一个 Runnable 的示例：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void runnableTest() {
System.out.println("=== RunnableTest ===");
// 一个匿名的 Runnable
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("Hello world one!");
}
};
// Lambda Runnable
Runnable r2 = () -> System.out.println("Hello world two!");
// 执行两个 run 函数
r1.run();
r2.run();
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void runnableTest() {
System.out.println("=== RunnableTest ===");
// 一个匿名的 Runnable
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("Hello world one!");
}
};
// Lambda Runnable
Runnable r2 = () -> System.out.println("Hello world two!");
// 执行两个 run 函数
r1.run();
r2.run();
}
这两个实现方式都没有参数也没有返回值。Runnable lambda 表达式使用代码块的方式把五行代码简化为一个语句。2 .Comparator Lambda
在 Java 中，Comparator 接口用来排序集合。在下面的示例中一个 ArrayList 中包含了一些 Person 对象， 并依据 Person 对象的 surName 来排序。下面是 Person 类中包含的 fields:
?
1
2
3
4
5
6
7
8
9
public class Person {
private String givenName;
private String surName;
private int age;
private Gender gender;
private String eMail;
private String phone;
private String address;
}
?
1
2
3
4
5
6
7
8
9
public class Person {
private String givenName;
private String surName;
private int age;
private Gender gender;
private String eMail;
private String phone;
private String address;
}
下面是分别用匿名内部类和 Lambda 表达式实现 Comparator 接口的方式：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class ComparatorTest {
public static void main(String[] args) {
List personList = Person.createShortList();
// 使用内部类实现排序
Collections.sort(personList, new Comparator() {
public int compare(Person p1, Person p2) {
return p1.getSurName().compareTo(p2.getSurName());
}
});
System.out.println("=== Sorted Asc SurName ===");
for (Person p : personList) {
p.printName();
}
// 使用 Lambda 表达式实现
// 升序排列
System.out.println("=== Sorted Asc SurName ===");
Collections.sort(personList, (Person p1, Person p2) -> p1.getSurName().compareTo(p2.getSurName()));
for (Person p : personList) {
p.printName();
}
// 降序排列
System.out.println("=== Sorted Desc SurName ===");
Collections.sort(personList, (p1, p2) -> p2.getSurName().compareTo(p1.getSurName()));
for (Person p : personList) {
p.printName();
}
}
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class ComparatorTest {
public static void main(String[] args) {
List personList = Person.createShortList();
// 使用内部类实现排序
Collections.sort(personList, new Comparator() {
public int compare(Person p1, Person p2) {
return p1.getSurName().compareTo(p2.getSurName());
}
});
System.out.println("=== Sorted Asc SurName ===");
for (Person p : personList) {
p.printName();
}
// 使用 Lambda 表达式实现
// 升序排列
System.out.println("=== Sorted Asc SurName ===");
Collections.sort(personList, (Person p1, Person p2) -> p1.getSurName().compareTo(p2.getSurName()));
for (Person p : personList) {
p.printName();
}
// 降序排列
System.out.println("=== Sorted Desc SurName ===");
Collections.sort(personList, (p1, p2) -> p2.getSurName().compareTo(p1.getSurName()));
for (Person p : personList) {
p.printName();
}
}
}
可以看到 匿名内部类可以通过 Lambda 表达式实现。注意 第一个 Lambda 表达式定义了参数的类型为 Person；而第二个 Lambda 表达式省略了该类型定义。Lambda 表达式支持类型推倒，如果通过上下文可以推倒出所需要的类型，则可以省略类型定义。这里由于 我们把 Lambda 表达式用在一个使用泛型定义的 Comparator 地方，编译器可以推倒出这两个参数类型为 Person 。
