Java 终于在 Java 8 中引入了 Lambda 表达式。也称之为闭包或者匿名函数。
本文首发于 blog.zhaochunqi.com 转载请注明 blog.zhaochunqi.com
根据JSR 335, Java 终于在 Java 8 中引入了 Lambda 表达式。也称之为闭包或者匿名函数。
![](http://upload-images.jianshu.io/upload_images/38763-50aa37db62227c3a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700/format/webp)
JSR 335
所谓的 JSR (Java Specification Requests) 全称叫做 Java 规范提案。简单来说就是向 Java 社区提交新的 API 或 服务 请求的提案。这些提案将作为 Java 社区进行 Java 语言开发的需求,引导着开发的方向。
JSR 335 的提案内容摘要如下:
This JSR will extend the Java Programming Language Specification and the Java Virtual Machine Specification to support the following features:
- Lambda Expressions
- SAM Conversion
- Method References
- Virtual Extension Methods
也就是如下几点:
- 支持 lambda 表达式。
- 支持 SAM conversion 用来向前兼容。
- 方法引用 Method References
- Virtual Extension Methods
在 Java 8 中,以上均已经实现,以上内容下文均有介绍。
为什么需要 Lambda 表达式?
Lambda 表达式,其实就是代码块。
![](http://upload-images.jianshu.io/upload_images/38763-5963cd486143e91f.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/309/format/webp)
原来怎么处理
在具体了解 lambda 之前,我们先往后退一步,看看之前我们是如何处理这些代码块的!
例子一
当决定在单独的线程运行某程序时,你这样做的
class Worker implements Runnable {
public void run() {
for (int i = 0; i < 1000; i++)
doWork();
}
...
}
这样执行:
Worker w = new Worker();
new Thread(w).start();
Worker 中包含了你要执行的代码块。
例子二
如果你想实现根据字符串长度大小来排序,而不是默认的字母顺序,你可以自己来实现一个 Comparator 用来 Sort。
class LengthComparator implements Comparator<String> {
public int compare(String first, String second) {
return Integer.compare(first.length(), second.length());
}
}
Arrays.sort(strings, new LengthComparator());
例子三
另外一个例子,我选的是 Android 中的点击事件,同样是 Java:
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Toast.makeText(MainActivity.this, "Hello World!", Toast.LENGTH_SHORT).show();
}
});
上面代码有什么问题呢?
![](http://upload-images.jianshu.io/upload_images/38763-6fec6d1d973373af.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/640/format/webp)
它们都太复杂了啊!
上述例子都是在某个类中实现某个接口,然后传递到另外一个方法中作为参数,然后用来执行。
但是本质上,他们要传递的就是接口中那一个方法的实现而已啊!有必要先创建类,再实例化,再传递给调用的位置吗?
因为 Java 是纯面向对象的语言,像其他语言那样随随便便传个方法过来,那可不行,必须要这样。
在其他语言中你可能可以,但是,在Java 中,不可以。
![](http://upload-images.jianshu.io/upload_images/38763-f006698693398098.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/281/format/webp)
Java 设计人员为了 Java 的简洁跟连贯性,一直拒绝为Java添加这种功能。(这也是我喜欢Java而不喜欢Python的原因啊!!!)
经过多年的努力,开发人员终于找到了符合 Java 编程习惯的 Lambda 表达式!
Lambda 表达式语法(Syntax)
考虑下前面的例子:
Integer.compare(first.length(), second.length())
first和second都是 String 类型,Java 是强类型的语言,必须指定类型:
(String first, String second)
-> Integer.compare(first.length(), second.length())
![](http://upload-images.jianshu.io/upload_images/38763-19971b69b2b4fa87.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/391/format/webp)
看到没有!第一个 Lambda 表达式诞生了!!输入、输出简洁明了!
为什么叫 Lambda 呢,这个很多年以前,有位逻辑学家想要标准化的表示一些可以被计算的数学方程(实际上存在,但是很难被表示出来),他就用 ℷ 来表示。
重新介绍一下 Java 中 Lambda 表达式的格式:
(参数) -> 表达式
多返回值
如果计算的结果并不由一个单一的表达式返回(换言之,返回值存在多种情况),使用“{}",然后明确指定返回值。
(String first, String second) -> {
if (first.length() < second.length()) return -1;
else if (first.length() > second.length()) return 1;
else return 0;
}
无参数
如果没有参数,则 "()"中就空着。
() -> { 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());
这里,first和second可以被推断出是 String 类型,因为 是一个 String 类型的 Comparator。
如果单个参数可以被推断出,你连括号都可以省略:
EventHandler<ActionEvent> listener = event ->
System.out.println("Thanks for clicking!");
// Instead of (event) -> or (ActionEvent event) ->
修饰符
你可以像对待其他方法一样,annotation,或者 使用 final 修饰符
(final String name) -> ...
(@NonNull String name) -> ...
永远不要定义 result 的类型,lambda 表达式总是从上下文中推断出来的:
(String first, String second) -> Integer.compare(first.length(), second.length())
注意
注意,在lambda 表达式中,某些分支存在返回值,某些不存在返回值这样的情况是不允许的。
如 (int x) -> { if (x >= 0) return 1; }
这样是非法的。
函数式接口(Functional Interfaces/SAM)
要介绍 Java 中 lambda 表达式的实现,需要知道什么是 函数式接口。
什么叫作函数式接口呢(SAM)?
函数式接口指的是只定义了唯一的抽象方法的接口(除了隐含的Object对象的公共方法), 因此最开始也就做SAM类型的接口(Single Abstract Method)。
Lambda 表达式向前兼容这些接口。
Comparable
举个例子 Array.sort:
Arrays.sort(words,
(first, second) -> Integer.compare(first.length(), second.length()));
Array.sort() 方法收到一个实现了 Comparable<String> 接口的实例。
其实可以把 Lambda 表达式想象成一个方法,而非一个对象,一个可以传入一个接口的方法。
OnClickListener
再举个例子
button.setOnClickListener(event ->
System.out.println("Thanks for clicking!"));
你看,是不是更易读了呢?
Lambda 表达式能够向前兼容这些 interfaces, 太棒了! 那 Lambda 表达式还能干什么呢?
实际上,将函数式接口转变成 lambda 表达式是你在 Java 中唯一能做的事情。
![](http://upload-images.jianshu.io/upload_images/38763-722af9bd1f4521ad.jpeg?imageMogr2/auto-orient/strip%7CimageView2/2/w/531/format/webp)
Why ?!!
在其他的语言中,你可以定义一些方便的方法类型,但在 Java 中,你甚至不能将一个Lambda表达式赋值给类型为 Object 的变量,因为 Object 变量不是一个 Functional Interface。
Java 的设计者们坚持使用熟悉的 interface 概念而不是为其引入新的 方法类型。
(这里我还要为设计者点赞!谨慎的设计,一方面降低了初学者的门槛,一方面方便了高级用户的使用。对比 python2和 python3,升级的不兼容让很多人一直停留在 python2)
Method References
能不能再简洁一点?有的时候我们所要做的事情不过是调用其他类中方法来处理事件。
button.setOnClickListener(event -> System.out.println(event));
如果这样呢?
button.setOnAction(System.out::println);
表达式 System.out::println
属于一个方法引用(method reference), 相当于 lambda 表达式 x -> System.out.println(x)
![](http://upload-images.jianshu.io/upload_images/38763-f10011e80209b862.jpeg?imageMogr2/auto-orient/strip%7CimageView2/2/w/700/format/webp)
再举个例子,如果你想对字符串不管大小写进行排序,就可以这样写!
Arrays.sort(strings, String::compareToIgnoreCase)
如上所见 ::
操作符将方法名与实例或者类分隔开。总体来说,又如下的规则:
- object::instanceMethod
- Class::staticMethod
- Class::instanceMethod
值得指出的是, this
和super
关键字可以在其中使用:
class Greeter {
public void greet() {
System.out.println("Hello, world!");
}
}
class ConcurrentGreeter extends Greeter {
public void greet() {
Thread t = new Thread(super::greet);
t.start();
}
}
构造方法引用 Constructor References
跟上一个差不多,毕竟构造方法 也是方法啊!!不过方法名字为 new 。
但是!这个构造方法引用有一个牛逼的地方!
你知道 Array 是不能使用范型的对吧!(什么,你不知道?看看这里 http://stackoverflow.com/questions/2927391/whats-the-reason-i-cant-create-generic-array-types-in-java),你没有办法创建一个类型为 T 的 Array 。 new T[n] 将会被覆盖为 new Object[n]。
假设我们想要一个包含 buttons 的 Array。Stream interface 可以返回一个 Object array。
Object[] buttons = stream.toArray();
不不不,我们可不想要 Object。Stream 库使用 构造方法引用解决了这个问题:
Button[] buttons = stream.toArray(Button[]::new);
![](http://upload-images.jianshu.io/upload_images/38763-ba1898c085847545.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1000/format/webp)
变量作用域
注意到我们在题目中写着 闭包(closure),实际上,闭包的定义是: 引用了自由变量的函数。
在之前,如果需要在匿名类的内部引用外部变量,需要将外部变量定义为 final ,现在有了 lambda 表达式,你不必再这么做了。但同样需要保证外部的自由变量不能在 lambda 表达式中被改变。
![](http://upload-images.jianshu.io/upload_images/38763-4c9e2a38377b8a25.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/288/format/webp)
这是什么意思呢? 不需要定义为 final,也不能改?
其实理解起来很简单,Java 8 中,不需要定义为 final ,但你其实可以直接把他当作 final,不要试图修改它就行了。
即便你用内部类,现在也无需定义为 final 了。
参考 StackOverFlow 链接: http://stackoverflow.com/questions/4732544/why-are-only-final-variables-accessible-in-anonymous-class
Default Methods
由于历史原因,像是类似 Collection 这种接口,如果进行添加接口的话,那将会造成之前的代码出错。
Java 想了一个一劳永逸的方法解决这个问题, 使用 default 修饰符来提供默认的实现
比如 Collection 接口的源代码:
default void remove() {
throw new UnsupportedOperationException("remove");
}
当没有 override remove 这个方法是,调用的时候返回 UnsupportedOperationException 错误。
Static Methods in Interfaces
Java 8 中,你可以在接口中添加静态方法了。 可能与你想的不太一样,但是呢,为了方便起见,现在 interface 可以有静态方法了。
参考链接:
- JSR 335: Lambda Expressions for the JavaTM Programming Language
- Java 8 新特性概述
- Lambda Expressions in Java 8
![](http://upload-images.jianshu.io/upload_images/38763-6dfd4e1040079c69.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1000/format/webp)
作者:AlexZhao
链接:https://www.jianshu.com/p/85affe38ce5c
来源:简书
简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。
java新手自学群 626070845
java/springboot/hadoop/JVM 群 4915800
Hadoop/mongodb(搭建/开发/运维)Q群481975850
GOLang Q1群:6848027
GOLang Q2群:450509103
GOLang Q3群:436173132
GOLang Q4群:141984758
GOLang Q5群:215535604
C/C++/QT群 1414577
单片机嵌入式/电子电路入门群群 306312845
MUD/LIB/交流群 391486684
Electron/koa/Nodejs/express 214737701
大前端群vue/js/ts 165150391
操作系统研发群:15375777
汇编/辅助/破解新手群:755783453
大数据 elasticsearch 群 481975850
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。