Java8 Lambda表达式详解手册及实例
先贩卖一下焦虑，java8发于2014年3月18日，距离现在已经快6年了，如果你对java8的新特性还没有应用，甚至还一无所知，那你真得关注公众号“程序新视界”，好好系列的学习一下java8的新特性。lambda表达式已经在新框架中普通使用了，如果你对lambda还一无所知，真得认真学习一下本篇文章了。
现在进入正题java8的lambda，首先看一下发音 ([ˈlæmdə])表达式。注意该词的发音，b是不发音的，da发[də]音。
为什么要引入lambda表达式
简单的来说，引入lambda就是为了简化代码，允许把函数作为一个方法的参数传递进方法中。如果有javascript的编程经验，马上会想到这不就是闭包吗。是的，lambda表达式也可以称作java中的闭包。
先回顾一下java8以前，如果想把某个接口的实现类作为参数传递给一个方法会怎么做？要么创建一个类实现该接口，然后new出一个对象，在调用方法时传递进去，要么使用匿名类，可以精简一些代码。以创建一个线程并打印一行日志为例，使用匿名函数写法如下：
new thread(new runnable() {
@override
public void run() {
system.out.println("欢迎关注公众号：程序新视界");
}
}).start();
在java8以前，使用匿名函数已经算是很简洁的写法了，再来看看使用lambda表达式，上面的代码会变成什么样子。
new thread(() -> system.out.println("欢迎关注公众号：程序新视界")).start();
是不是简洁到爆！
我们都知道java是面向对象的编程语言，除了部分简单数据类型，万物皆对象。因此，在java中定义函数或方法都离不开对象，也就意味着很难直接将方法或函数像参数一样传递，而java8中的lambda表达式的出现解决了这个问题。
lambda表达式使得java拥有了函数式编程的能力，但在java中lambda表达式是对象，它必须依附于一类特别的对象类型——函数式接口(functional interface)，后面详细讲解。
lambda表达式简介
lambda表达式是一种匿名函数(对java而言这并不完全准确)，通俗的说，它是没有声明的方法，即没有访问修饰符、返回值声明和名字的方法。使用lambda表达式的好处很明显就是可以使代码变的更加简洁紧凑。
lambda表达式的使用场景与匿名类的使用场景几乎一致，都是在某个功能（方法）只使用一次的时候。
lambda表达式语法结构
lambda表达式通常使用(param)->(body)语法书写，基本格式如下：
//没有参数
() -> body
// 1个参数
(param) -> body
// 或
(param) ->{ body; }
// 多个参数
(param1, param2...) -> { body }
// 或
(type1 param1, type2 param2...) -> { body }
常见的lambda表达式如下：
// 无参数,返回值为字符串“公众号：程序新视界” () -> "公众号：程序新视界"; // 1个string参数，直接打印结果 (system.out::println); // 或 (string s) -> system.out.print(s) // 1个参数(数字),返回2倍值 x -> 2 * x; // 2个参数(数字),返回差值 (x, y) -> x – y // 2个int型整数,返回和值 (int x, int y) -> x + y
对照上面的示例，我们再总结一下lambda表达式的结构：
- lambda表达式可以有0~n个参数。
- 参数类型可以显式声明，也可以让编译器从上下文自动推断类型。如(int x)和(x)是等价的。
- 多个参数用小括号括起来，逗号分隔。一个参数可以不用括号。
- 没有参数用空括号表示。
- lambda表达式的正文可以包含零条，一条或多条语句，如果有返回值则必须包含返回值语句。如果只有一条可省略大括号。如果有一条以上则必须包含在大括号（代码块）中。
函数式接口
函数式接口(functional interface)是java8对一类特殊类型的接口的称呼。这类接口只定义了唯一的抽象方法的接口（除了隐含的object对象的公共方法），因此最开始也就做sam类型的接口（single abstract method）。
比如上面示例中的java.lang.runnable就是一种函数式接口，在其内部只定义了一个void run()的抽象方法，同时在该接口上注解了@functionalinterface。
@functionalinterface
public interface runnable {
public abstract void run();
}
@functionalinterface注解是用来表示该接口要符合函数式接口的规范，除了隐含的object对象的公共方法以外只可有一个抽象方法。当然，如果某个接口只定义一个抽象方法，不使用该注解也是可以使用lambda表达式的，但是没有该注解的约束，后期可能会新增其他的抽象方法，导致已经使用lambda表达式的地方出错。使用@functionalinterface从编译层面解决了可能的错误。
比如当注解@functionalinterface之后，写两个抽象方法在接口内，会出现以下提示：
multiple non-overriding abstract methods found in interface com.secbro2.lambda.noparaminterface
通过函数式接口我们也可以得出一个简单的结论：可使用lambda表达式的接口，只能有一个抽象方法（除了隐含的object对象的公共方法）。
注意此处的方法限制为抽象方法，如果接口内有其他静态方法则不会受限制。
方法引用，双冒号操作
[方法引用]的格式是，类名::方法名。
像如classname::methodname或者objectname::methodname的表达式，我们把它叫做方法引用（method reference）,通常用在lambda表达中。
看一下示例：
// 无参数情况 noparaminterface paraminterface2 = ()-> new hashmap<>(); // 可替换为 noparaminterface paraminterface1 = hashmap::new; // 一个参数情况 oneparaminterface oneparaminterface1 = (string string) -> system.out.print(string); // 可替换为 oneparaminterface oneparaminterface2 = (system.out::println); // 两个参数情况 comparator c = (computer c1, computer c2) -> c1.getage().compareto(c2.getage()); // 可替换为 comparator c = (c1, c2) -> c1.getage().compareto(c2.getage()); // 进一步可替换为 comparator c = comparator.comparing(computer::getage);
再比如我们用函数式接口java.util.function.function来实现一个string转integer的功能，可以如下写法：
function<string, integer> function = integer::parseint;
integer num = function.apply("1");
根据function接口的定义function<t,r>，其中t表示传入类型，r表示返回类型。具体就是实现了function的apply方法，在其方法内调用了integer.parseint方法。
通过上面的讲解，基本的语法已经完成，以下内容通过实例来逐一演示在不同的场景下如何使用。
runnable线程初始化示例
runnable线程初始化是比较典型的应用场景。
// 匿名函类写法
new thread(new runnable() {
@override
public void run() {
system.out.println("欢迎关注公众号：程序新视界");
}
}).start();
// lambda表达式写法
new thread(() -> system.out.println("欢迎关注公众号：程序新视界")).start();
// lambda表达式 如果方法体内有多行代码需要带大括号
new thread(() -> {
system.out.println("欢迎关注公众号");
system.out.println("程序新视界");
}).start();
通常都会把lambda表达式内部变量的名字起得短一些，这样能使代码更简短。
事件处理示例
swing api编程中经常会用到的事件监听。
// 匿名函类写法
jbutton follow = new jbutton("关注");
follow.addactionlistener(new actionlistener() {
@override
public void actionperformed(actionevent e) {
system.out.println("已关注公众号：程序新视界");
}
});
// lambda表达式写法
follow.addactionlistener((e) -> system.out.println("已关注公众号：程序新视界"));
// lambda表达式写法
follow.addactionlistener((e) -> {
system.out.println("已关注公众号");
system.out.println("程序新视界");
});
列表遍历输出示例
传统遍历一个list，基本上都使用for循环来遍历，java8之后list拥有了foreach方法，可配合lambda表达式写出更加简洁的方法。
list<string> list = arrays.aslist("欢迎","关注","程序新视界");
// 传统遍历
for(string str : list){
system.out.println(str);
}
// lambda表达式写法
list.foreach(str -> system.out.println(str));
// lambda表达式写法
list.foreach(system.out::println);
函数式接口示例
在上面的例子中已经看到函数式接口java.util.function.function的使用，在java.util.function包下中还有其他的类，用来支持java的函数式编程。比如通过predicate函数式接口以及lambda表达式，可以向api方法添加逻辑，用更少的代码支持更多的动态行为。
@test
public void testpredicate() {
list<string> list = arrays.aslist("欢迎", "关注", "程序新视界");
filter(list, (str) -> ("程序新视界".equals(str)));
filter(list, (str) -> (((string) str).length() == 5));
}
public static void filter(list<string> list, predicate condition) {
for (string content : list) {
if (condition.test(content)) {
system.out.println("符合条件的内容：" + content);
}
}
}
其中filter方法中的写法还可以进一步简化：
list.stream().filter((content) -> condition.test(content)).foreach((content) ->system.out.println("符合条件的内容：" + content));
list.stream().filter(condition::test).foreach((content) ->system.out.println("符合条件的内容：" + content));
list.stream().filter(condition).foreach((content) ->system.out.println("符合条件的内容：" + content));
如果不需要“符合条件的内容:”字符串的拼接，还能够进一步简化：
list.stream().filter(condition).foreach(system.out::println);
如果将调用filter方法的判断条件也写在一起，test方法中的内容可以通过一行代码来实现：
list.stream().filter((str) -> ("程序新视界".equals(str))).foreach(system.out::println);
如果需要同时满足两个条件或满足其中一个即可，predicate可以将这样的多个条件合并成一个。
predicate start = (str) -> (((string) str).startswith("程序"));
predicate len = (str) -> (((string) str).length() == 5);
list.stream().filter(start.and(len)).foreach(system.out::println);
stream相关示例
在《java8 stream新特性详解及实战》一文中已经讲解了stream的使用。你是否发现stream的使用都离不开lambda表达式。是的，所有stream的操作必须以lambda表达式为参数。
以stream的map方法为例：
stream.of("a","b","c").map(item -> item.touppercase()).foreach(system.out::println);
stream.of("a","b","c").map(string::touppercase).foreach(system.out::println);
更多的使用实例可参看stream的《java8 stream新特性详解及实战》一文。
lambda表达式与匿名类的区别
- 关键词的区别：对于匿名类，关键词this指向匿名类，而对于lambda表达式，关键词this指向包围lambda表达式的类的外部类，也就是说跟表达式外面使用this表达的意思是一样。
- 编译方式：java编译器编译lambda表达式时，会将其转换为类的私有方法，再进行动态绑定，通过invokedynamic指令进行调用。而匿名内部类仍然是一个类，编译时编译器会自动为该类取名并生成class文件。
其中第一条，以spring boot中servletwebserverapplicationcontext类的一段源码作为示例：
private org.springframework.boot.web.servlet.servletcontextinitializer getselfinitializer() {
return this::selfinitialize;
}
private void selfinitialize(servletcontext servletcontext) throws servletexception {
preparewebapplicationcontext(servletcontext);
registerapplicationscope(servletcontext);
webapplicationcontextutils.registerenvironmentbeans(getbeanfactory(),servletcontext);
for (servletcontextinitializer beans : getservletcontextinitializerbeans()) {
beans.onstartup(servletcontext);
}
}
其中，这里的this指向的就是getselfinitializer方法所在的类。
小结
至此，java8 lambda表达式的基本使用已经讲解完毕，最关键的还是要勤加练习，达到熟能生巧的使用。当然，刚开始可能需要一个适应期，在此期间可以把本篇文章收藏当做一个手册拿来参考。
原文链接：《java8 lambda表达式详解手册及实例》