在使用 Lambda 表达式的时候,我们实际上传递进去的代码就是一种解决方案:拿什么参数做什么操作。那么考虑一种情况:如果我们在 Lambda 中所指定的操作方案,已经有地方存在相同方案,那是否还有必要再写重复逻辑?
1. 冗余的Lambda场景
来看一个简单的函数式接口以应用 Lambda 表达式:
@FunctionalInterface
public interface Printable {
void print(String s);
}
在Printable
接口当中唯一的抽象方法print()
接收一个字符串参数,目的就是为了打印显示它。那么通过 Lambda 来使用它的代码很简单:
public class Demo {
public static void printString(Printable p) {
p.print("Hello World");
}
public static void main(String[] args) {
printString(s -> System.out.println(s));
}
}
输出结果:
Hello World
问题分析
这段代码的问题在于,对字符串进行控制台打印输出的操作方案,明明已经有了现成的实现,那就是System.out
对象中的println(String)
方法。既然 Lambda 希望做的事情就是调用println(String)
方法,那何必自己手动调用呢?
用方法引用改进代码
public class Demo {
public static void printString(Printable p) {
p.print("Hello World");
}
public static void main(String[] args) {
printString(System.out::println);
}
}
请注意其中的双冒号
::
写法,这被称为“方法引用”,而双冒号是一种新的语法。
2. 方法引用符
双冒号::
为引用运算符,而它所在的表达式被称为方法引用。如果 Lambda 要表达的函数方案已经存在于某个方法的实现中,那么则可以通过双冒号来引用该方法作为 Lambda 的替代者。
2.1 语义分析
例如上例中, System.out
对象中有一个重载的println(String)
方法恰好就是我们所需要的。那么对于printString()
方法的函数式接口参数,对比下面两种写法,完全等效:
- Lambda 表达式写法:
s -> System.out.println(s);
- 方法引用写法:
System.out::println
第一种语义是指:拿到参数之后经 Lambda之手,继而传递给System.out.println()
方法去处理。
第二种等效写法的语义是指:直接让System.out
中的println()
方法来取代 Lambda。两种写法的执行效果完全一样,而第二种方法引用的写法复用了已有方案,更加简洁。
Lambda 中传递的参数一定是方法引用中的那个方法可以接收的类型,否则会抛出异常
2.2 推导与省略
如果使用 Lambda,那么根据“可推导就是可省略”的原则,无需指定参数类型,也无需指定的重载形式——它们都将被自动推导。而如果使用方法引用,也是同样可以根据上下文进行推导。
函数式接口是 Lambda 的基础,而方法引用是 Lambda 的孪生兄弟。
下面这段代码将会调用println()
方法的不同重载形式,将函数式接口改为int
类型的参数:
@FunctionalInterface
public interface Printable {
void print(int s);
}
public class Demo {
public static void printString(Printable p) {
p.print(323);
}
public static void main(String[] args) {
printString(System.out::println);
}
}
输出结果:
323
3. 通过对象名引用成员方法
这是最常见的一种用法,与上例相同。如果一个类中已经存在了一个成员方法:
public class MethodRefObject {
public void printUpperCase(String str) {
System.out.println(str.toUpperCase());
}
}
函数式接口仍然定义为:
@FunctionalInterface
public interface Printable {
void print(String s);
}
那么当需要使用这个printUpperCase()
成员方法来替代Printable
接口的 Lambda 的时候,已经具有了MethodRefObject
类的对象实例,则可以通过对象名引用成员方法,代码为:
public class Demo {
private static void printString(Printable lambda) {
lambda.print("Hello");
}
public static void main(String[] args) {
MethodRefObject obj = new MethodRefObject();
printString(obj::printUpperCase);
}
}
输出结果:
HELLO
4. 通过类名称引用静态方法
由于在java.lang.Math
类中已经存在了静态方法abs()
,所以当我们需要通过Lambda来调用该方法时,有两种写
法。首先是函数式接口:
@FunctionalInterface
public interface Calcable {
int calc(int num);
}
第一种写法是使用 Lambda 表达式:
public class Demo {
private static void method(int num, Calcable lambda) {
System.out.println(lambda.calc(num));
}
public static void main(String[] args) {
method(-10, n -> Math.abs(n));
}
}
输出结果:
10
但是使用方法引用的更好写法是:
public class Demo {
private static void method(int num, Calcable lambda) {
System.out.println(lambda.calc(num));
}
public static void main(String[] args) {
method(-10, Math::abs);
}
}
5. 通过super引用成员方法
如果存在继承关系,当 Lambda 中需要出现super()
调用时,也可以使用方法引用进行替代。首先是函数式接口:
@FunctionalInterface
public interface Greetable {
void greet();
}
然后是父类Human
的内容:
public class Human {
public void sayHello() {
System.out.println("Hello!");
}
}
最后是子类Man
的内容,其中使用了 Lambda 的写法
public class Man extends Human {
@Override
public void sayHello() {
System.out.println("大家好,我是Man!");
}
//定义方法method,参数传递Greetable接口
public void method(Greetable g) {
g.greet();
}
public void show() {
//调用method方法,使用Lambda表达式
method(() -> {
//创建Human对象,调用sayHello方法
new Human().sayHello();
});
//简化Lambda
method(() -> new Human().sayHello());
//使用super关键字代替父类对象
method(() -> super.sayHello());
}
}
但是如果使用方法引用来调用父类中的sayHello()
方法会更好,例如另一个子类Woman
:
public class Woman extends Human {
@Override
public void sayHello() {
System.out.println("大家好,我是Woman!");
}
//定义方法method,参数传递Greetable接口
public void method(Greetable g) {
g.greet();
}
public void show() {
method(super::sayHello);
}
}
6. 通过this引用成员方法
this
代表当前对象,如果需要引用的方法就是当前类中的成员方法,那么可以使用this::成员方法
的格式来使用方法引用。首先是简单的函数式接口:
@FunctionalInterface
public interface Richable {
void buy();
}
下面是一个丈夫Husband
类:
public class Husband {
private void marry(Richable lambda) {
lambda.buy();
}
public void beHappy() {
marry(() -> System.out.println("买套房子"));
}
}
开心方法beHappy()
调用了结婚方法marry()
,后者的参数为函数式接口Richable
,所以需要一个 Lambda 表达式。但是如果这个 Lambda 表达式的内容已经在本类当中存在了,则可以对Husband
丈夫类进行修改:
public class Husband {
private void buyHouse() {
System.out.println("买套房子");
}
private void marry(Richable lambda) {
lambda.buy();
}
public void beHappy() {
marry(() -> this.buyHouse());
}
}
如果希望取消掉 Lambda 表达式,用方法引用进行替换,则更好的写法为:
public class Husband {
private void buyHouse() {
System.out.println("买套房子");
}
private void marry(Richable lambda) {
lambda.buy();
}
public void beHappy() {
marry(() -> this::buyHouse;
}
}
7. 类的构造器引用
由于构造器的名称与类名完全一样,并不固定。所以构造器引用使用类名称::new
的格式表示。首先是一个简单的Person
类:
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
然后是用来创建Person
对象的函数式接口:
@FunctionalInterface
public interface PersonBuilder {
Person buildPerson(String name);
}
要使用这个函数式接口,可以通过 Lambda 表达式:
public class Demo {
public static void printName(String name, PersonBuilder builder) {
System.out.println(builder.buildPerson(name).getName());
}
public static void main(String[] args) {
printName("赵丽颖", name -> new Person(name));
}
}
但是通过构造器引用,有更好的写法:
public class Demo {
public static void printName(String name, PersonBuilder builder) {
System.out.println(builder.buildPerson(name).getName());
}
public static void main(String[] args) {
printName("赵丽颖", Person::new);
}
}
8. 数组的构造器引用
数组也是Object
的子类对象,所以同样具有构造器,只是语法稍有不同。如果对应到 Lambda 的使用场景中时,需要一个函数式接口:
@FunctionalInterface
public interface ArrayBuilder {
int[] buildArray(int length);
}
在应用该接口的时候,可以通过Lambda
表达式:
public class Demo {
private static int[] initArray(int length, ArrayBuilder builder) {
return builder.buildArray(length);
}
public static void main(String[] args) {
int[] array = initArray(10, length -> new int[length]);
}
}
但是更好的写法是使用数组的构造器引用:
public class Demo {
private static int[] initArray(int length, ArrayBuilder builder) {
return builder.buildArray(length);
}
public static void main(String[] args) {
int[] array = initArray(10, int[]::new);
}
}
在这个例子中,下面两种写法是等效的:
- Lambda 表达式:
length -> new int[length]
- 方法引用:
int[]::new