Lambda表达式

假设有一个List容器:

List fruits = Arrays.asList(
    new Fruit("香蕉"),
    new Fruit("苹果"),
    new Fruit("梨子"),
    new Fruit("西瓜"),
    new Fruit("荔枝")
);

进行遍历,打印水果的名字:

for (int i = 0; i < fruits.size(); i++) {
  Fruit f = fruits.get(i);
  System.out.println(f.getName());
}

如果使用Java 8新特性:

fruits.forEach(f -> {
  System.out.println(f.getName());
});

实际上,两种循环遍历的方式是等价的,功能相同。但使用新特性的代码更简洁紧凑。


基本定义

Lambda表达式的基本结构是

f -> { }
Lambda表达式_第1张图片

作为参数的变量名,是可以自定义的,不是固定的

Lambda 表达式在功能上等同于一个匿名方法:

public void unknown(f) {
  System.out.println(f.getName());
}

相当于方法名和 public void 修饰符都省略了。

类型识别

f 变量的类型是什么呢?答案是:类型是系统根据上下文 自动 识别的。

回顾:

List fruits = Arrays.asList(......);

fruits.forEach(f -> {
  System.out.println(f.getName());
});

forEach() 方法表示循环遍历 fruits 集合,每次循环时 f 变量指代当前遍历到的元素。

由于 fruits 变量的类型使用泛型语法定义为 List,表示集合中元素的类型是 Fruit

所以,f 变量的类型自然是 Fruit,就可以调用 Fruit 类的方法了。

forEach() 方法是 Java 集合的循环遍历的方法,暂时先记住这种用法

所以,Lambda 表达式要配合上下文、跟其他方法配合使用,而不是一个独立的语句。这么写的就是错误的:

public static void main(String[] args) {
  args[0] -> {
    System.out.println(args[0]);
  }
}

实战案例

可以使用 Lambda 表达式对集合的排序进行代码优化:

List students = new ArrayList();
students.add(new Student(111, "bbbb", "london"));
students.add(new Student(131, "aaaa", "nyc"));
students.add(new Student(121, "cccc", "jaipur"));

// 实现升序排序
Collections.sort(students, (student1, student2) -> {
  // 第一个参数的学号 vs 第二个参数的学号
  return student1.getRollNo() - student2.getRollNo();
});

students.forEach(s -> System.out.println(s));

Collections.sort() 方法第二个参数是实现匿名类 new Comparator(){} ,为什么能使用 Lambda 优化呢?留在后面的章节讲解,暂时不用纠结。这里先记住这个知识点即可。

Lambda 表达式又有了一些新的写法:

多参数

箭头(->)前表示参数变量,有 多个参数 的时候,必须使用小括号包裹:()

(student1, student2) -> {}

无参数

箭头(->)前表示参数变量,没有参数 的时候,必须使用小括号:()

() -> {}

单条执行语句

箭头(->)后的执行语句 只有一条 时,可以不加大括号 {} 包裹

s -> System.out.println(s);

大家在写代码时,无论几条语句,都 推荐 加上大括号 {},这样代码块的边界明确。

有类型参数

大多数情况下为了简介省略类型,如果代码比较复杂,可以为参数变量指定类型

fruits.forEach((Fruit f) -> {
  System.out.println(f.getName());
});
  • 即使只有一个参数,也必须使用小括号()包裹,否则会出错。

引用外部变量

Lambda表示式{}内的执行语句,除了能引用参数变量以外,还可以引用外部的变量。

List fruits = Arrays.asList(......);
String message = "水果名称:";

fruits.forEach(f -> {
  System.out.println(message + f.getName());
});

message = "";

执行后可以看到报错了:

错误: 从lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量
这段错误提示是什么意思呢?

规范一

因为使用 Lambda 表达式有规范:引用的 局部变量 不允许被修改。

即使写在表达式后面也不行

下列代码修改了局部变量也是错误的:

String message;

fruits.forEach(f -> {
  message = "水果名称:";
});

我们写过 final 关键字,Lambda 表达式引用的 局部变量 即使不声明为 final,也要具备 final 的特性:变量值初始化后不允许被修改。

  • 在表达式外实际值赋值一次的写法是允许的:
String message;
message = "水果名称:";

规范二

使用 Lambda 表达式还有一点需要注意:参数不能与 局部变量 同名。下列写法是错误的:

String f = "水果名称:";
fruits.forEach(f -> {});

双冒号(::)操作符

java8支持了一种新的语法:双冒号::,这也是一种Lambda写法,是与Lambda表达式相关的一个重要特性。

List names = Arrays.asList("zhangSan", "LiSi", "WangWu");

names.forEach(n -> {
  System.out.println(n);
});

可以简化为:

names.forEach(System.out::println);

使用:: 时,系统每次遍历取得的元素(n),会 自动 作为参数传递给 System.out.println() 方法打印输出:

System.out::println 等同于 n -> {System.out.println(n);}

:: 语法干脆省略了参数变量,所以读这段代码需要相互对照、并且自行脑补

语法含义

Lambda表达式_第2张图片

双冒号 :: 语法,当然也是不能独立使用的,需要配合特定的方法(属于后面章节的内容,稍安勿躁)

不同用法

用法一:静态方法调用

使用 :: 语法调用静态方法:

使用 LambdaTest::print 代替 f -> LambdaTest.print(f),简化了代码。

用法二:调用非静态方法

print() 方法不再标识为 static,于是需要实例对象来调用。

fruits.forEach(new LambdaTest()::print);

只是简写了:

LambdaTest lt = new LambdaTest();
fruits.forEach(lt::print);

效果是一样的。

实际上,本节开头的案例中,System.out::println 语句就是调用非静态方法 println(),因为 System.out 指代的是一个实例对象。

用法三:多参数

Collections.sort(students, (student1, student2) -> {
  // 第一个参数的学号 vs 第二个参数的学号
  return student1.getRollNo() - student2.getRollNo();
});

如果把比较的过程定义成一个方法:

private static int compute(Student s1, Student s2) {
  ... ...
  ... ...
}

那么,排序过程就可以简写为:

Collections.sort(students, SortTest::compute);

注意,系统会 自动 获取上下文的参数,并按上下文定义的 顺序 传递给指定的方法。所谓 顺序 就是 Lambda 表达式 () 中的顺序。

与变量名无关,s1 s2 命名只是便于理解

用法四:父类方法

我们在《Java面向对象》学过,super 关键字的作用是在子类中引用父类的属性或者方法。那么同样,:: 语法也可以用 super 关键字调用父类的非静态方法。

你可能感兴趣的:(Lambda表达式)