为什么使用lambda表达式
先看几个例子：
第一个例子，在一个独立的线程中执行某项任务，我们通常这么实现：
我要评论
class worker implements runnable {
public void run() {
for (int i = 0; i < 100; i++)
dowork();
}
...
}
worker w = new worker();
new thread(w).start();
第二个例子，自定义字符串比较的方法（通过字符串长度），一般这么做：
class lengthcomparator implements comparator<string> {
public int compare(string first, string second) {
return integer.compare(first.length(), second.length());
}
}
arrays.sort(strings, new lengthcomparator());
第三个例子，在javafx中，给一个button添加一个callback：
button.setonaction(new eventhandler<actionevent>() {
public void handle(actionevent event) {
system.out.println("thanks for clicking!");
}
});
这些例子有一个共同点，就是：先定义一段代码块，传给某个对象或方法，然后被执行。在lambda表
达式之前，java是不允许直接传递代码块的，因为java是面向对象的，因此必须传递一个对象，将要
执行的代码块封装到对象里。
lambda表达式的语法
将上面第二个例子中的lengthcomparator，用lambda表达式表示为：
(string first, string second) -> integer.compare(first.length(), second.length());
->前为参数列表，其后为表达式语句体；
如果表达式语句体不止一行，则将语句体写在{}中，与普通的函数一样：
(string first, string second) -> {
if (first.length() > second.length()) {
return 1;
} else if (first.length() == second.length()) {
return 0;
} else {
return -1;
}
};
如果没有参数，()还是需要带上，比如上面的第一个例子，可以表示为：
() -> {
for (int i = 0; i < 1000; i ++) {
dowork();
}
}
如果参数的类型可以从上下文自动推断，则可以省略：
comparator<string> comp = (first, second) // same as (string first, string second) -> integer.compare(first.length(), second.length());
如果参数只有一个，且类型可以自动推断，则小括号()也可以省略：
// instead of (event) -> or (actionevent event) ->
eventhandler<actionevent> listener =
event -> system.out.println("thanks for clicking!");
lambda表达式的返回值的类型是自动推断的，因此不需要指明；在lambda表达式，某些条件分支中有
返回值，而其它分支没有返回值，是不允许的，如：
(x) -> {
if (x >= 0) {
return 1;
}
}
另外，expression lambda和statement lambda的区别是，expression lambda不需要
写return关键字，java runtime会将表达式的结果作为返回值返回，而statement lambda是
写在{}中的表达式，需要使用return关键字，比如：
// expression lambda
comparator<string> comp1 =
(first, second) -> integer.compare(first.length(), second.length());
// statement lambda
comparator<string> comp2 = (first, second) ->
{ return integer.compare(first.length(), second.length());};
functional interface
如果一个接口（interface）仅有一个抽象方法（abstract method），就称为
functional interface，比如runnable、comparator等。
在任何一个需要functional interface对象的地方，都可以使用lambda表达式：
arrays.sort(words, (first, second) -> integer.compare(first.length(), second.length()));
这里，sort()的第二个参数需要的是一个comparator对象，而comparator是
functional interface，因此可以直接传入lambda表达式，在调用该对象的compare()方法
时，就是执行该lambda表达式中的语句体；
如果lambda表达式的语句体会抛出异常，则对应的functional interface中的抽象方法必须抛
出了该异常，否则就需要在lambda表达式中显式捕获异常：
runnable r = () -> {
system.out.println("------");
try {
thread.sleep(10);
} catch (interruptedexception e) {
// catch exception
}
};
callable<string> c = () -> {
system.out.println("--------");
thread.sleep(10);
return "";
};
method reference
如果将lambda表达式的参数作为参数传递给一个方法，他们的执行效果是相同的，则该lambda表达式
可以使用method reference表达，以下两种方式是等价的：
(x) -> system.out.println(x) system.out::println
其中system.out::println被称为method reference。
method reference主要有三种形式：
对于前两种方式，对应的lambda表达式的参数和method的参数是一致的，比如：
system.out::println (x) -> system.out.println(x) math::pow (x, y) -> math.pow(x, y)
对于第三种方式，对应的lambda表达式的语句体中，第一个参数作为对象，调用method，将其它参数
作为method的参数，比如：
string::comparetoignorecase (s1, s2) -> s1.comparetoignorecase(s2) 1.5 constructor reference
constructor reference与method reference类似，只不过是特殊的method：new，具体调用的是哪个构造函数，由上下文环境决定，比如：
list<string> labels = ...; stream<button> stream = labels.stream().map(button::new);
button::new等价于(x) -> button(x)，所以调用的构造函数是：button(x);
除了创建单个对象，也可以创建对象数组，如下面两种方式等价：
int[]::new (x) -> new int[x]
变量作用域
lambd表达式会捕获当前作用域下可用的变量，比如：
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();
}
但是这些变量必须是不可变的，为什么呢？看下面这个例子：
int matches = 0;
for (path p : files)
new thread(() -> { if (p has some property) matches++; }).start();
// illegal to mutate matches
因为可变的变量在lambda表达式中不是线程安全的，这和内部类的要求是一致的，内部类中只能引用
外部定义的final变量；
lambda表达式的作用域与嵌套代码块的作用域是一样的，所以在lambd表达式中的参数名或变量名不
能与局部变量冲突，如：
path first = paths.get("/usr/bin");
comparator<string> comp = (first, second) -> integer.compare(first.length(),
second.length()); // error: variable first already defined
如果在lambda表达式中引用this变量，则引用的是创建该lambda表达式的方法的this变量，如：
public class application() {
public void dowork() {
runnable runner = () -> {
...;
system.out.println(this.tostring());
...
};
}
}
所以这里的this.tostring()调用的是application对象的tostring()，而不是runnable
对象的。
default method
接口中只能有抽象方法，如果在已有的接口中新增一个方法，则该接口所有的实现类都需要实现该方法。
java 8中引入了default method的概念，在接口中新增一个default方法，不会破坏已有的接
口规则，接口的实现类可以选择重写或直接继承该default方法，比如：
interface person {
long getid();
default string getname() { return "john q. public"; }
}
java是允许多继承的，如果一个类的父类中定义的方法和接口中定义的default方法完全相同，或者
一个类的两个接口中定义了完全相同的方法， 则如何处理这种冲突呢？处理规则如下：
如果是父类和接口的方法冲突：以父类中的方法为准，接口中的方法被忽略；
如果两个接口中的default方法冲突，则需要重写该方法解决冲突；
static method
java 8之前，接口中只能定义static变量，java 8开始，接口中可以添加static方法，比如
comparator接口新增了一系列comparingxxx的static方法，比如：
public static <t> comparator<t> comparingint(tointfunction<? super t>
keyextractor) {
objects.requirenonnull(keyextractor);
return (comparator<t> & serializable)
(c1, c2) -> integer.compare(keyextractor.applyasint(c1),
keyextractor.applyasint(c2));
}
使用这个static方法，以下两种方式也是等价的：
1、
arrays.sort(cities, (first, second) -> integer.compare(first.length(), second.length()));
2、
arrays.sort(cities, comparator.comparingint(string::length));
所以，以后我们在设计自己的接口时，不需要再定义单独的工具类（如collections/collection)，
在接口中使用static方法就行了。
匿名内部类
在 java 世界中，匿名内部类 可以实现在应用程序中可能只执行一次的操作。例如，在 android 应用程序中，一个按钮的点击事件处理。你不需要为了处理一个点击事件单独编写一个独立的类，可以用匿名内部类完成该操作：
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 示例
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();
}
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();
}
public class person {
private string givenname;
private string surname;
private int age;
private gender gender;
private string email;
private string phone;
private string address;
}
public class person {
private string givenname;
private string surname;
private int age;
private gender gender;
private string email;
private string phone;
private string address;
}
public class comparatortest {
public static void main(string[] args) {
list<person> personlist = person.createshortlist();
// 使用内部类实现排序
collections.sort(personlist, new comparator<person>() {
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();
}
}
}
public class comparatortest {
public static void main(string[] args) {
list<person> personlist = person.createshortlist();
// 使用内部类实现排序
collections.sort(personlist, new comparator<person>() {
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();
}
}
}
如对本文有疑问， 点击进行留言回复！！
![[JVM学习之路]一、初识JVM，了解其结构、模型及生命周期](http://www.lhsxpumps.com/_images5/10qianwan/20200726/s_0_202007261744394527.png)
[JVM学习之路]一、初识JVM，了解其结构、模型及生命周期
【JAVA并发编程】LinkedBlockingQueue原理
网友评论