Java 8 的 Lambda 表达式的实现方式还是基于已有的字节码指令,由 Lambda 表达式的方法签名结合上下文并经由 SAM 推断出正确的类型来。Java 8 的 Lambda 完整书写格式是
(type parameter1 [type parameter2, ...type parametern]) -> { statements here }
这种标准格式所表示的就是方法签名。
虽不及其他语言的 Lambda 表达式,像 Swift, Scala 可省略参数部分,可用默认参数名 $0, $1, 或 _, 但 Java 8 的 Lambda 还是可以进行酌情简化
参数类型总是可省略 -- (x, y) -> { x + y; }
参数为一个时,参数括号可省略 -- x -> { System.out.println(x); }
语句为一条时,可省略大括号, 并且语句后不要分号 -- x -> System.out.println(x)
上面更进一步,如果是单条 return 语句,必须把 return 关键字去掉 -- x -> "Hello " + x
就差一点,参数部分总是不能省,无参必须写成 () -> System.out.println("hi")
Java 8 中若要近似的实现无参数部分写法,那就是方法引用了 -- System.out::println
. 参数类型总是可省略, 基本上我们总是省略掉参数类型
interface Function {
void call(String x, String y);
}
void foo(Function f) {
f.call("a", "b");
}
foo((x, y) -> { //(x, y) 完整写法是 (String x, String y)
System.out.println(x);
System.out.println(y);
});
1
2
3
4
5
6
7
8
9
10
11
12
interfaceFunction{
voidcall(Stringx,Stringy);
}
voidfoo(Functionf){
f.call("a","b");
}
foo((x,y)->{ //(x, y) 完整写法是 (String x, String y)
System.out.println(x);
System.out.println(y);
});
. 参数为一个时,参数括号省略
interface Function {
void call(String x);
}
Function f = x -> {
System.out.println();
System.out.println(x);
};
f.call("Hello");
1
2
3
4
5
6
7
8
9
interfaceFunction{
voidcall(Stringx);
}
Functionf=x->{
System.out.println();
System.out.println(x);
};
f.call("Hello");
. 语句为一条时,可省略大括号, 并且语句后不要分号
interface Function {
void call(String x);
}
void foo(Function f) {
f.call("Hi");
}
foo(x -> System.out.println(x)); //不能写成 foo(x -> System.out.println(x);); 这像话
1
2
3
4
5
6
7
8
9
interfaceFunction{
voidcall(Stringx);
}
voidfoo(Functionf){
f.call("Hi");
}
foo(x->System.out.println(x));//不能写成 foo(x -> System.out.println(x);); 这像话
. 如果是单条 return 语句,省去大括时必须把 return 关键字去掉
interface Function {
void String call(String x);
}
foo(x -> "Hello " + x)
1
2
3
4
5
interfaceFunction{
voidStringcall(Stringx);
}
foo(x->"Hello "+x)
. 参数部分的括号总是需要
interface Function {
void call();
}
Function f = () -> System.out.println();
1
2
3
4
5
interfaceFunction{
voidcall();
}
Functionf=()->System.out.println();
不写出 -> 来似乎不知道这是一个 Lambda.
Java 8 中目前还无法简化成类似于 Swift/Scala 中的 foo(System.out.println()) 或 foo {System.out.println()}。不过可以采用方法引用的方式,只是方法引用有其缺陷--不能捕获外部变量。
public class TestLambda {
public static void main(String[] args) {
foo(TestLambda::todo); //todo 方法的签名正好是 x -> String
}
static void foo(Function f){
System.out.println(f.call("World"));
}
static String todo(String x) { //也就是这个方法正好符合 Function 的 SAM 方法签名
return "Hello " + x;
}
}
interface Function {
String call(String x);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
publicclassTestLambda{
publicstaticvoidmain(String[]args){
foo(TestLambda::todo);//todo 方法的签名正好是 x -> String
}
staticvoidfoo(Functionf){
System.out.println(f.call("World"));
}
staticStringtodo(Stringx){//也就是这个方法正好符合 Function 的 SAM 方法签名
return"Hello "+x;
}
}
interfaceFunction{
Stringcall(Stringx);
}
前面说过用方法引用的缺陷是无法捕外部变量,譬如用 Lambda 的方式
String external = "ABC";
foo(x -> external + x);
1
2
Stringexternal="ABC";
foo(x->external+x);
而在前面的 todo 方法中却访问不到 external 变量,如果给 todo 再增加一个参数来传递 external 则不符合 Function 的 SAM 的签名了。
除非,除非用实例的方法引用,那么需要每次传入外部参数来构造实例,例如这样
public class TestLambda {
public static void main(String[] args) {
String external = "ABC";
foo(new MethodProvider(external)::todo); //输出 Hello ABC World
}
static void foo(Function f){
System.out.println(f.call("World"));
}
}
class MethodProvider {
private String _external;
public MethodProvider(String external) {
this._external = external;
}
String todo(String x) {
return "Hello " + _external + " " + x;
}
}
interface Function {
String call(String x);
}
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
publicclassTestLambda{
publicstaticvoidmain(String[]args){
Stringexternal="ABC";
foo(newMethodProvider(external)::todo);//输出 Hello ABC World
}
staticvoidfoo(Functionf){
System.out.println(f.call("World"));
}
}
classMethodProvider{
privateString_external;
publicMethodProvider(Stringexternal){
this._external=external;
}
Stringtodo(Stringx){
return"Hello "+_external+" "+x;
}
}
interfaceFunction{
Stringcall(Stringx);
}
这样着实有些怪异,而且有点把欲作简化的东西复杂化了。