概述
方法引用的基础是 Lambda 表达式，它可以认为是 Lambda 表达式的语法糖，用来简化开发。
在我们使用Lambda表达式的时候，-> 右边部分是要执行的代码，即要完成的功能，可以把这部分称作 Lambda 体。有时候，当我们想要实现一个函数式接口的那个抽象方法，但是已经有类实现了我们想要的功能，这个时候我们就可以用方法引用来直接使用现有类的功能去实现。
四种形式
引用静态方法
语法: 类名::静态方法名
例如: String::valueOf 对应的 Lambda 表达式为 s ->String.valueOf(s)
引用特定对象实例的方法
语法: 对象::对象方法
例如: obj::toString 对应的 Lambda 表达式为 obj -> obj.toString()
引用特定类型任意对象的实例方法
语法: 类名::对象方法
例如: String::compareTo 对应的 Lambda 表达式为 (str1, str2) -> str1.compareTo(str2)
注意: 这种形式不太容易理解，虽然 compareTo 方法只需要一个参数，但是其对应的 Lambda 表达式中却有两个参数，其中第一个参数是 调用 compareTo 方法的对象本身。
引用构造方法
语法: 类名::new
例如: String::new 对应 Lambda 表达式的 () -> new String()
例子
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
| package info.andrewei;
import java.util.Arrays;
import java.util.List;
import java.util.function.Supplier;
public class Main {
public static void main(String[] args) {
Student str1 = new Student("zhangsan", 10);
Student str2 = new Student("lisi", 50);
Student str3 = new Student("wangwu", 40);
Student str4 = new Student("zhaoliu", 30);
List<Student> list;
list = Arrays.asList(str1, str2, str3, str4);
list.sort(StudentCompare::staticCompareStudentsByName);
list.forEach(stu -> System.out.println(stu.getName()));
list.sort(StudentCompare::staticCompareStudentsByScore);
list.forEach(stu -> System.out.println(stu.getScore()));
System.out.println("---------------------");
StudentCompare studentCompator = new StudentCompare();
list = Arrays.asList(str1, str2, str3, str4);
list.sort(studentCompator::compareStudentsByName);
list.forEach(stu -> System.out.println(stu.getName()));
list.sort(studentCompator::compareStudentsByScore);
list.forEach(stu -> System.out.println(stu.getScore()));
System.out.println("---------------------");
list = Arrays.asList(str1, str2, str3, str4);
list.sort(Student::comparedByName);
list.forEach(stu -> System.out.println(stu.getName()));
list.sort(Student::comparedByScore);
list.forEach(stu -> System.out.println(stu.getScore()));
System.out.println("---------------------");
System.out.println(Student.getStudent(String::new));
}
static class Student {
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
public static Student getStudent(Supplier<String> nameSupplier) {
return new Student(nameSupplier.get()+"_test", 10);
}
public String getName() {
return name;
}
public int getScore() {
return score;
}
public int comparedByScore(Student stu1) {
return this.score - stu1.getScore();
}
public int comparedByName(Student stu1) {
return this.name.compareTo(stu1.getName());
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", score=" + score +
'}';
}
}
static class StudentCompare {
public static int staticCompareStudentsByScore(Student stu1, Student stu2) {
return stu1.getScore() - stu2.getScore();
}
public static int staticCompareStudentsByName(Student stu1, Student stu2) {
return stu1.getName().compareTo(stu2.getName());
}
public int compareStudentsByScore(Student stu1, Student stu2) {
return stu1.getScore() - stu2.getScore();
}
public int compareStudentsByName(Student stu1, Student stu2) {
return stu1.getName().compareTo(stu2.getName());
}
}
}
|
