什么是Lambda表达式：用于简化匿名内部类代码的书写。
Lambda表达式基本使用
Lamdba是有特有的格式的，按照下面的格式来编写Lamdba。
1
2
3
| (被重写方法的形参列表) -> {
被重写方法的方法体代码;
}
|
需要给说明一下的是，在使用Lambda表达式之前，必须先有一个接口，而且接口中只能有一个抽象方法。（注意：不能是抽象类，只能是接口）
像这样的接口，我们称之为函数式接口，只有基于函数式接口的匿名内部类才能被Lambda表达式简化。
像这样
1
2
3
| public interface Swimming{
void swim();
}
|
代码案例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| public interface Swimming {
void swim();
}
public class LambdaTest {
public static void main(String[] args) {
go(new Swimming() {
@Override
public void swim() {
System.out.println("匿名内部类方法执行了");
}
});
go(() -> {
System.out.println("Lambda表达式执行了");
});
}
public static void go(Swimming s){
s.swim();
}
}
|
使用Lambda简化数组排序
基本类型数组
由于接口Comparable只能传递泛型，所以基本类型不能作为参数传递进去，这里基本类型只能对其长度进行规则排序。
代码案例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| import java.util.Arrays;
import java.util.Comparator;
public class MyStringTest {
public static void main(String[] args) {
String[] arr = {"a", "bb", "ccc", "dddd", "e"};
Arrays.sort(arr, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length() - o2.length();
}
});
System.out.println(Arrays.toString(arr));
System.out.println("可以使用Lambda表达式简化对数组的排序规则");
Arrays.sort(arr, (a, b) -> b.length() - a.length());
System.out.println(Arrays.toString(arr));
}
}
|
泛型类型数组
代码案例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public class LambdaStringSort {
public static void main(String[] args) {
Integer[] arr = {1, 5, 8, 2, 3, 9, 6};
Arrays.sort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});
System.out.println(Arrays.toString(arr));
System.out.println("使用Lambda对其进行简化");
Arrays.sort(arr, (a, b) -> b - a);
System.out.println(Arrays.toString(arr));
}
}
|
Lambda表达式省略规则(※)
Java觉得代码还不够简单，于是还提供了Lamdba表达式的几种简化写法。具体的简化规则如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| 1.Lambda的标准格式
(参数类型1 参数名1, 参数类型2 参数名2)->{
...方法体的代码...
return 返回值;
}
2.在标准格式的基础上()中的参数类型可以直接省略
(参数名1, 参数名2)->{
...方法体的代码...
return 返回值;
}
3.如果{}总的语句只有一条语句，则{}可以省略、return关键字、以及最后的“;”都可以省略
(参数名1, 参数名2)-> 结果
4.如果()里面只有一个参数，则()可以省略
(参数名)->结果
|
代码案例
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
| public class LambdaTest2 {
public static void main(String[] args) {
double[] prices = {99.8, 128, 100};
Arrays.setAll(prices, new IntToDoubleFunction() {
@Override
public double applyAsDouble(int value) {
return prices[value] * 0.8;
}
});
Arrays.setAll(prices, (int value) -> {
return prices[value] * 0.8;
});
Arrays.setAll(prices, (value) -> {
return prices[value] * 0.8;
});
Arrays.setAll(prices, value -> {
return prices[value] * 0.8;
});
Arrays.setAll(prices, value -> prices[value] * 0.8 );
System.out.println(Arrays.toString(prices));
System.out.println("------------------------------------
Student[] students = new Student[4];
students[0] = new Student("蜘蛛精", 169.5, 23);
students[1] = new Student("紫霞", 163.8, 26);
students[2] = new Student("紫霞", 163.8, 26);
students[3] = new Student("至尊宝", 167.5, 24);
//1.使用匿名内部类
Arrays.sort(students, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return Double.compare(o1.getHeight(), o2.getHeight()); // 升序
}
});
//2.使用Lambda表达式表达式——标准格式
Arrays.sort(students, (Student o1, Student o2) -> {
return Double.compare(o1.getHeight(), o2.getHeight()); // 升序
});
//3.使用Lambda表达式表达式——省略参数类型
Arrays.sort(students, ( o1, o2) -> {
return Double.compare(o1.getHeight(), o2.getHeight()); // 升序
});
//4.使用Lambda表达式表达式——省略{}
Arrays.sort(students, ( o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight()));
System.out.println(Arrays.toString(students));
}
}
|
微信
支付宝