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 表达式和抽象函数中参数的类型。

相关文章
|
6天前
|
Java 数据处理 开发者
Java中的Lambda表达式:简化你的代码之路
【8月更文挑战第66天】Lambda表达式在Java 8中首次引入,它为Java开发者提供了一种更简洁、更灵活的编程方式。本文将通过简单易懂的语言和实际代码示例,引导你理解Lambda表达式的基本概念、语法结构以及如何在Java项目中应用它来简化代码。无论你是Java新手还是有经验的开发者,这篇文章都将帮助你更好地掌握这一强大的工具。
34 11
|
6天前
|
Java API
Java中的Lambda表达式:一种简洁而强大的编程工具
本文将深入探讨Java中的Lambda表达式,它是一种简洁而强大的编程工具。通过本文,您将了解Lambda表达式的基本概念、语法结构以及使用方法。我们还将介绍Lambda表达式的应用场景和最佳实践,并通过实例演示其在简化代码、提高可读性和编写并行代码方面的优势。最后,我们将讨论使用Lambda表达式时需要注意的一些事项和限制。无论您是初学者还是有经验的Java开发人员,都可以从本文中获得有价值的知识和技能。现在,让我们一起探索Java中Lambda表达式的奇妙世界吧!
|
12天前
|
Java
探索Java中的Lambda表达式
【9月更文挑战第28天】Lambda表达式,这一Java 8引入的轻量级语法结构,为函数式编程提供了强有力的支持。它简化了代码,提高了开发效率,并使得并行处理数据变得异常容易。本文将通过直观的例子和详细的解释,带领读者深入理解Lambda表达式的奥秘,从而在编程实践中更加灵活地运用它们。
|
13天前
|
Java API
探索Java中的Lambda表达式
【9月更文挑战第27天】Lambda表达式,作为Java 8的一大亮点,为我们的编程世界带来了一股清新之风。它以其简洁明了的语法和强大的功能,让我们在处理集合、线程等复杂操作时如鱼得水。本文将带你一探Lambda表达式的奥秘,让你领略到它的魅力所在。
18 6
|
10天前
|
Java 开发者
探索Java中的Lambda表达式:简化你的代码之旅##
【8月更文挑战第62天】 Java 8的发布为开发者带来了诸多新特性,其中最引人注目的无疑是Lambda表达式。这一特性不仅让代码变得更加简洁,还极大地提升了开发的效率。本文将通过实际示例,展示如何利用Lambda表达式来优化我们的代码结构,同时探讨其背后的工作原理和性能考量。 ##
|
11天前
|
Java API 开发者
探索Java中的Lambda表达式
【9月更文挑战第29天】Lambda表达式,在Java编程中,它不仅仅是一种语法糖,更是简化代码、提升效率的利器。本文将通过浅显易懂的语言和实际代码示例,带你走进Lambda的世界,了解其背后的原理和在日常开发中的应用,让你的代码更简洁、更高效。
|
13天前
|
Java API 开发者
探索Java中的Lambda表达式:简化代码,提升效率
【9月更文挑战第27天】在Java 8中引入的Lambda表达式为编程带来了革命性的变化。通过简洁的语法和强大的功能,它不仅简化了代码编写过程,还显著提升了程序的执行效率。本文将深入探讨Lambda表达式的本质、用法和优势,并结合实例演示其在实际开发中的应用。无论你是Java新手还是资深开发者,都能从中获得启发,优化你的代码设计。
|
16天前
|
Java 程序员 API
Java 8新特性之Lambda表达式与Stream API的探索
【9月更文挑战第24天】本文将深入浅出地介绍Java 8中的重要新特性——Lambda表达式和Stream API,通过实例解析其语法、用法及背后的设计哲学。我们将一探究竟,看看这些新特性如何让Java代码变得更加简洁、易读且富有表现力,同时提升程序的性能和开发效率。
|
2月前
|
Java API
Java 8新特性:Lambda表达式与Stream API的深度解析
【7月更文挑战第61天】本文将深入探讨Java 8中的两个重要特性:Lambda表达式和Stream API。我们将首先介绍Lambda表达式的基本概念和语法,然后详细解析Stream API的使用和优势。最后,我们将通过实例代码演示如何结合使用Lambda表达式和Stream API,以提高Java编程的效率和可读性。
|
2月前
|
存储 算法 Oracle
19 Java8概述(Java8概述+lambda表达式+函数式接口+方法引用+Stream+新时间API)
19 Java8概述(Java8概述+lambda表达式+函数式接口+方法引用+Stream+新时间API)
61 8