Java8
# 8.Java8
# Lambda 表达式
Lambda 表达式,也称为闭包,它允许函数作为一个方法的参数(函数作为参数传递进方法中),
# 语法
(parameters) -> expression
或(parameters) ->{statements; }
以下是lambda表达式的重要特征:
可选类型声明:不需要声明参数类型,编译器可以统一识别参数值。
可选的参数圆括号:一个参数无需定义圆括号,但多个参数需要定义圆括号。
可选的大括号:如果主体包含了一个语句,就不需要使用大括号。
可选的返回关键字:如果主体只有一个表达式返回值则编译器会自动返回值,大括号需要指定明表达式返回了一个数值。
public class Java8Tester1 {
public static void main(String args[]) {
Java8Tester1 tester = new Java8Tester1();
// 类型声明
MathOperation addition = (int a, int b) -> a + b;
// 不用类型声明
MathOperation subtraction = (a, b) -> a - b;
// 大括号中的返回语句
MathOperation multiplication = (int a, int b) -> {
return a * b;
};
// 没有大括号及返回语句
MathOperation division = (int a, int b) -> a / b;
System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
System.out.println("10 / 5 = " + tester.operate(10, 5, division));
// 不用括号
GreetingService greetService1 = message ->
System.out.println("Hello " + message);
// 用括号
GreetingService greetService2 = (message) ->
System.out.println("Hello " + message);
greetService1.sayMessage("Runoob");
greetService2.sayMessage("Google");
}
interface MathOperation {
int operation(int a, int b);
}
interface GreetingService {
void sayMessage(String message);
}
private int operate(int a, int b, MathOperation mathOperation) {
return mathOperation.operation(a, b);
}
}
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
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
使用Lambda 表达式可以使代码变的更加简洁紧凑,更具有表达性。
# 变量作用域
lambda 表达式只能引用标记了 final 的外层局部变量,这就是说不能在lambda 内部修改定义在域外的局部变量(基本数据类型的值,对象类型的地址),否则会编译错误。
例如:以下代码会报错
public class Java8Tester2 {
public static void main(String args[]) {
//隐性的具有final 的语义
int num = 1;
Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
s.convert(2);
num = 2;
}
public interface Converter<T1, T2> {
void convert(int i);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
个人理解是:lambda表达式中对变量的操作都是基于原变量的副本,为了保证局部变量和lambda中的副本的数据一致性,所以默认有隐式final。
# 方法引用
类型 | 语法 | 对应的Lambda表达式 |
---|---|---|
静态方法引用 | 类名::staticMethod | (args) -> 类名.staticMethod(args) |
实例方法引用 | inst::instMethod | (args) -> inst.instMethod(args) |
对象方法引用 | 类名::instMethod | (inst,args) -> 类名.instMethod(args) |
构建方法引用 | 类名::new | (args) -> new 类名(args) |
# 函数式接口
接口 | 输入参数 | 返回类型 | 说明 |
---|---|---|---|
UnaryOperator | T | T | 一元函数,输入输出类型相同 |
Predicate | T | boolean | 断言 |
Consumer | T | / | 消费一个数据,只有输入没有输出 |
Function<T,R> | T | R | 输入 T 返回 R,有输入也有输出 |
Supplier | / | T | 提供一个数据,没有输入只有输出 |
BiFunction<T,U,R> | (T,U) | R | 两个输入参数 |
BiPredicate<L, R> | (L,R) | boolean | 两个输入参数 |
BiConsumer<T, U> | (T,U) | void | 两个输入参数 |
BinaryOperator | (T,T) | T | 二元函数,输入输出类型相同 |
# Stream ApI
上次更新: 2022/04/01, 15:14:40