开发者社区> 千锋Python讲堂> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

Java 8:一文带你掌握 Lambda 表达式

简介: 本期教程将介绍 Java 8 新增的 Lambda 表达式,包括 Lambda 表达式的常见用法以及方法引用的用法,并对 Lambda 表达式的原理进行分析,最后对 Lambda 表达式的优缺点进行一个总结。
+关注继续查看

本期教程将介绍 Java 8 新增的 Lambda 表达式,包括 Lambda 表达式的常见用法以及方法引用的用法,并对 Lambda 表达式的原理进行分析,最后对 Lambda 表达式的优缺点进行一个总结。

概述

Java 8 引入的 Lambda 表达式的主要作用就是简化部分匿名内部类的写法。

能够使用 Lambda 表达式的一个重要依据是必须有相应的函数接口。所谓函数接口,是指内部有且仅有一个抽象方法的接口。

Lambda 表达式的另一个依据是类型推断机制。在上下文信息足够的情况下,编译器可以推断出参数表的类型,而不需要显式指名。

常见用法

2.1 无参函数的简写

无参函数就是没有参数的函数,例如 Runnable 接口的 run() 方法,其定义如下:

@FunctionalInterface

public interface Runnable {

public abstract void run();

}
在 Java 7 及之前版本,我们一般可以这样使用:

new Thread(new Runnable() {

@Override

public void run() {

System.out.println("Hello");

System.out.println("Jimmy");

}

}).start();
从 Java 8 开始,无参函数的匿名内部类可以简写成如下方式:

() -> {

执行语句

}
这样接口名和函数名就可以省掉了。那么,上面的示例可以简写成:

new Thread(() -> {

System.out.println("Hello");

System.out.println("Jimmy");

}).start();
当只有一条语句时,我们还可以对代码块进行简写,格式如下:

() -> 表达式
注意这里使用的是表达式,并不是语句,也就是说不需要在末尾加分号。

那么,当上面的例子中执行的语句只有一条时,可以简写成这样:

new Thread(() -> System.out.println("Hello")).start();

2.2 单参函数的简写

单参函数是指只有一个参数的函数。例如 View 内部的接口 OnClickListener 的方法 onClick(View v),其定义如下:

public interface OnClickListener {

/**

  • Called when a view has been clicked.

*

  • @param v The view that was clicked.

*/

void onClick(View v);

}
在 Java 7 及之前的版本,我们通常可能会这么使用:

view.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View v) {

v.setVisibility(View.GONE);

}

});
从 Java 8 开始,单参函数的匿名内部类可以简写成如下方式:

([类名 ]变量名) -> {

执行语句

}
其中类名是可以省略的,因为 Lambda 表达式可以自己推断出来。那么上面的例子可以简写成如下两种方式:

view.setOnClickListener((View v) -> {

v.setVisibility(View.GONE);

});

view.setOnClickListener((v) -> {

v.setVisibility(View.GONE);

});
单参函数甚至可以把括号去掉,官方也更建议使用这种方式:

变量名 -> {

执行语句

}
那么,上面的示例可以简写成:

view.setOnClickListener(v -> {

v.setVisibility(View.GONE);

});
当只有一条语句时,依然可以对代码块进行简写,格式如下:

([类名 ]变量名) -> 表达式
类名和括号依然可以省略,如下:

变量名 -> 表达式
那么,上面的示例可以进一步简写成:

view.setOnClickListener(v -> v.setVisibility(View.GONE));

2.3 多参函数的简写

多参函数是指具有两个及以上参数的函数。例如,Comparator 接口的 compare(T o1, T o2) 方法就具有两个参数,其定义如下:

@FunctionalInterfacepublic interface Comparator {

int compare(T o1, T o2);

}
在 Java 7 及之前的版本,当我们对一个集合进行排序时,通常可以这么写:

List list = Arrays.asList(1, 2, 3);Collections.sort(list, new Comparator() {

@Override

public int compare(Integer o1, Integer o2) {

return o1.compareTo(o2);

}

});
从 Java 8 开始,多参函数的匿名内部类可以简写成如下方式:

([类名1 ]变量名1, [类名2 ]变量名2[, ...]) -> {

执行语句

}
同样类名可以省略,那么上面的例子可以简写成:

Collections.sort(list, (Integer o1, Integer o2) -> {

return o1.compareTo(o2);

});

Collections.sort(list, (o1, o2) -> {

return o1.compareTo(o2);

});
当只有一条语句时,依然可以对代码块进行简写,格式如下:

([类名1 ]变量名1, [类名2 ]变量名2[, ...]) -> 表达式
此时类名也是可以省略的,但括号不能省略。如果这条语句需要返回值,那么 return 关键字是不需要写的。

因此,上面的示例可以进一步简写成:

Collections.sort(list, (o1, o2) -> o1.compareTo(o2));
最后呢,这个示例还可以简写成这样:

Collections.sort(list, Integer::compareTo);
咦,这是什么特性?这就是我们下面要讲的内容:方法引用。

三. 方法引用

方法引用也是一个语法糖,可以用来简化开发。

在我们使用 Lambda 表达式的时候,如果“->”的右边要执行的表达式只是调用一个类已有的方法,那么就可以用「方法引用」来替代 Lambda 表达式。

方法引用可以分为 4 类:

引用静态方法;
引用对象的方法;
引用类的方法;
引用构造方法。
下面按照这 4 类分别进行阐述。

3.1 引用静态方法

当我们要执行的表达式是调用某个类的静态方法,并且这个静态方法的参数列表和接口里抽象函数的参数列表一一对应时,我们可以采用引用静态方法的格式。

假如 Lambda 表达式符合如下格式:

([变量1, 变量2, ...]) -> 类名.静态方法名([变量1, 变量2, ...])
我们可以简写成如下格式:

类名::静态方法名
注意这里静态方法名后面不需要加括号,也不用加参数,因为编译器都可以推断出来。下面我们继续使用 2.3 节的示例来进行说明。

首先创建一个工具类,代码如下:

public class Utils {

public static int compare(Integer o1, Integer o2) {

return o1.compareTo(o2);

}

}
注意这里的 compare() 函数的参数和 Comparable 接口的 compare() 函数的参数是一一对应的。然后一般的 Lambda 表达式可以这样写:

Collections.sort(list, (o1, o2) -> Utils.compare(o1, o2));
如果采用方法引用的方式,可以简写成这样:

Collections.sort(list, Utils::compare);
3.2 引用对象的方法

当我们要执行的表达式是调用某个对象的方法,并且这个方法的参数列表和接口里抽象函数的参数列表一一对应时,我们就可以采用引用对象的方法的格式。

假如 Lambda 表达式符合如下格式:

([变量1, 变量2, ...]) -> 对象引用.方法名([变量1, 变量2, ...])
我们可以简写成如下格式:

对象引用::方法名
下面我们继续使用 2.3 节的示例来进行说明。首先创建一个类,代码如下:

public class MyClass {

public int compare(Integer o1, Integer o2) {

return o1.compareTo(o2);

}

}
当我们创建一个该类的对象,并在 Lambda 表达式中使用该对象的方法时,一般可以这么写:

MyClass myClass = new MyClass();

Collections.sort(list, (o1, o2) -> myClass.compare(o1, o2));
注意这里函数的参数也是一一对应的,那么采用方法引用的方式,可以这样简写:

MyClass myClass = new MyClass();

Collections.sort(list, myClass::compare);
此外,当我们要执行的表达式是调用 Lambda 表达式所在的类的方法时,我们还可以采用如下格式:

this::方法名
例如我在 Lambda 表达式所在的类添加如下方法:

private int compare(Integer o1, Integer o2) {

return o1.compareTo(o2);

}
当 Lambda 表达式使用这个方法时,一般可以这样写:

Collections.sort(list, (o1, o2) -> compare(o1, o2));
如果采用方法引用的方式,就可以简写成这样:

Collections.sort(list, this::compare);
3.3 引用类的方法

引用类的方法所采用的参数对应形式与上两种略有不同。如果 Lambda 表达式的“->”的右边要执行的表达式是调用的“->”的左边第一个参数的某个实例方法,并且从第二个参数开始(或无参)对应到该实例方法的参数列表时,就可以使用这种方法。

可能有点绕,假如我们的 Lambda 表达式符合如下格式:

(变量1[, 变量2, ...]) -> 变量1.实例方法([变量2, ...])
那么我们的代码就可以简写成:

变量1对应的类名::实例方法名
还是使用 2.3 节的例子, 当我们使用的 Lambda 表达式是这样时:

Collections.sort(list, (o1, o2) -> o1.compareTo(o2));
按照上面的说法,就可以简写成这样:

Collections.sort(list, Integer::compareTo);
3.4 引用构造方法

当我们要执行的表达式是新建一个对象,并且这个对象的构造方法的参数列表和接口里函数的参数列表一一对应时,我们就可以采用「引用构造方法」的格式。

假如我们的 Lambda 表达式符合如下格式:

([变量1, 变量2, ...]) -> new 类名([变量1, 变量2, ...])
我们就可以简写成如下格式:

类名::new

下面举个例子说明一下。Java 8 引入了一个 Function 接口,它是一个函数接口,部分代码如下:

@FunctionalInterfacepublic interface Function {

/**

  • Applies this function to the given argument.

*

  • @param t the function argument
  • @return the function result

*/

R apply(T t);

// 省略部分代码

}
我们用这个接口来实现一个功能,创建一个指定大小的 ArrayList。一般我们可以这样实现:

Function function = new Function() {

@Override

public ArrayList apply(Integer n) {

return new ArrayList(n);

}

};

List list = function.apply(10);
使用 Lambda 表达式,我们一般可以这样写:

Function function = n -> new ArrayList(n);
使用「引用构造方法」的方式,我们可以简写成这样:

Function function = ArrayList::new;
四. 自定义函数接口

自定义函数接口很容易,只需要编写一个只有一个抽象方法的接口即可,示例代码:

@FunctionalInterfacepublic interface MyInterface {

void function(T t);

}
上面代码中的 @FunctionalInterface 是可选的,但加上该注解编译器会帮你检查接口是否符合函数接口规范。就像加入 @Override 注解会检查是否重写了函数一样。

五. 实现原理

经过上面的介绍,我们看到 Lambda 表达式只是为了简化匿名内部类书写,看起来似乎在编译阶段把所有的 Lambda 表达式替换成匿名内部类就可以了。但实际情况并非如此,在 JVM 层面,Lambda 表达式和匿名内部类其实有着明显的差别。

5.1 匿名内部类的实现

匿名内部类仍然是一个类,只是不需要我们显式指定类名,编译器会自动为该类取名。比如有如下形式的代码:

public class LambdaTest {

public static void main(String[] args) {

new Thread(new Runnable() {

@Override

public void run() {

System.out.println("Hello World");

}

}).start();

}

}
编译之后将会产生两个 class 文件:

LambdaTest.class

LambdaTest$1.class
使用 javap -c LambdaTest.class 进一步分析 LambdaTest.class 的字节码,部分结果如下:

public static void main(java.lang.String[]); Code: 0: new #2 // class java/lang/Thread 3: dup 4: new #3 // class com/example/myapplication/lambda/LambdaTest$1 7: dup 8: invokespecial #4 // Method com/example/myapplication/lambda/LambdaTest$1."":()V 11: invokespecial #5 // Method java/lang/Thread."":(Ljava/lang/Runnable;)V

14: invokevirtual #6 // Method java/lang/Thread.start:()V

17: return
可以发现在 4: new #3 这一行创建了匿名内部类的对象。

5.2 Lambda 表达式的实现

接下来我们将上面的示例代码使用 Lambda 表达式实现,代码如下:

public class LambdaTest {

public static void main(String[] args) {

new Thread(() -> System.out.println("Hello World")).start();

}

}
此时编译后只会产生一个文件 LambdaTest.class,再来看看通过 javap 对该文件反编译后的结果:

public static void main(java.lang.String[]); Code: 0: new #2 // class java/lang/Thread 3: dup 4: invokedynamic #3, 0 // InvokeDynamic #0:run:()Ljava/lang/Runnable; 9: invokespecial #4 // Method java/lang/Thread."":(Ljava/lang/Runnable;)V

12: invokevirtual #5 // Method java/lang/Thread.start:()V

15: return
从上面的结果我们发现 Lambda 表达式被封装成了主类的一个私有方法,并通过 invokedynamic 指令进行调用。

因此,我们可以得出结论:Lambda 表达式是通过 invokedynamic 指令实现的,并且书写 Lambda 表达式不会产生新的类。

既然 Lambda 表达式不会创建匿名内部类,那么在 Lambda 表达式中使用 this 关键字时,其指向的是外部类的引用。

**六. 优缺点
**
优点:

可以减少代码的书写,减少匿名内部类的创建,节省内存占用。

使用时不用去记忆所使用的接口和抽象函数。

缺点:

易读性较差,阅读代码的人需要熟悉 Lambda 表达式和抽象函数中参数的类型。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Java 8 新特性之 Lambda表达式
Lambda的出现就是为了增强Java面向过程编程的深度和灵活性。今天就来分享一下在Java中经常使用到的几个示例,通过对比分析,效果应该会更好。 – 1、实现Runnable线程案例 其存在的意义就是用Lambda来代替匿名类,如下: // before java 8...
696 0
java8新特性(二)_lambda表达式
最近一直找java8相关新特性的文章,发现都太没有一个连贯性,毕竟大家写博客肯定都有自己的侧重点,这里找到一本书,专门介绍java8新特性的,感觉大家可以看看《写给大忙人看的JavaSE8》.这里我会结合书中的知识以及网上的知识,对于java8 的新特性进行总结,当然我自己写的也会有自己的侧重点。
1339 0
Java 8 新特性(一)lambda表达式
Java 9 好像也快出了,不过我连Java 8的新特性都还没认真研究过,所以这几篇文章就是来介绍Java 8的新特性的。首先,第一个重要的特性就是传说中的lambda表达式了,虽然初学可能觉得这东西很难理解,但是一旦学会了,你就会发现离不开它了。
513 0
Java8新特性之一:Lambda表达式
Java8新特性之一:Lambda表达式Java8是自java5之后最重大的一次更新,它给JAVA语言带来了很多新的特性(包括编译器、类库、工具类、JVM等),其中最重要的升级是它给我们带来了Lambda表达式和Stream API。
996 0
好程序员分享java8新特性之Lambda表达式
好程序员分享java8新特性之Lambda表达式 ⼀、Lambda表达式简介 什么是Lambda? Lambda表达式是Java 8推出的⼀个新特性。从本质上讲,Lambda表达式是⼀个匿名函数。 为什么要使⽤Lambda? 使⽤Lambda表达式可以对⼀个接⼝进⾏⾮常简洁的实现。
1205 0
Java8.0新特性之Lambda表达式
  好程序员Java教程分享Java8.0新特性之Lambda表达式:Java 8 已经发布很久了,很多报道表明Java 8 是一次重大的版本升级。本篇文章,主要给大家介绍的是lambda表达式。 Lambda表达式 Lambda表达式(也称为闭包)是Java 8中最大和最令人期待的语言改变。
606 0
在java 8 stream表达式中实现if/else逻辑
在java 8 stream表达式中实现if/else逻辑
0 0
Java8新特性-Lambda表达式
Lambda表达式简化了我们代码开发,使得我们开发的代码看起来更加的简洁,所以我们需要学习这种更加规范、更加简洁的代码格式。
0 0
Java 8 新特性:Lambda 表达式
Java 8 新特性:Lambda 表达式
0 0
+关注
千锋Python讲堂
Python忠实粉!从业Python已有6年!希望在这里跟大家一起分享我的经验和同伴交流!
文章
问答
文章排行榜
最热
最新
相关电子书
更多
Java基础入门(四)-泛型、反射、注解
立即下载
Java开发手册1.4.0
立即下载
Java开发手册1.0.0版
立即下载