代码收藏家技术教程 2024-10-06

【Java系列】Lambda表达式深度解析（二）

Lambda 表达式在 Java 中引入于 Java 8，它使得函数式编程的实现变得更加容易和直观。接下来，我们将详细探讨 Java 中
Lambda 表达式的语法、用法以及相关特性。

1. Lambda 表达式的基本语法

Lambda 表达式的基本语法如下：

(parameters) -> expression

或者

(parameters) -> { statements }

1.1 语法元素

参数：可以是一个或多个参数，类型可以省略（编译器会进行类型推断）。

箭头操作符 (->)：将参数与表达式或语句块分开。

表达式：可以是单个表达式或一个语句块。

1.2 示例

// 无参数
() -> System.out.println("Hello, World!");

// 一个参数
x -> x * x;

// 两个参数
(x, y) -> x + y;

// 语句块
(x, y) -> {
    int sum = x + y;
    return sum;
};

2. 使用 Lambda 表达式

2.1 作为函数式接口的实现

Lambda 表达式通常用于实现函数式接口。函数式接口是只包含一个抽象方法的接口。

2.1.1 定义函数式接口

@FunctionalInterface
interface MyFunction {
    int apply(int x, int y);
}

2.1.2 使用 Lambda 表达式实现接口

MyFunction add = (x, y) -> x + y;
System.out.println(add.apply(2, 3));  // 输出 5

2.2 结合集合 API

Lambda 表达式与 Java 的集合框架结合使用，尤其是在 Stream API 中。

2.2.1 使用 `forEach`

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println(name));

2.2.2 使用 `map`

List<Integer> lengths = names.stream()
    .map(name -> name.length())
    .collect(Collectors.toList());
System.out.println(lengths);  // 输出 [5, 3, 7]

2.2.3 使用 `filter`

List<String> filteredNames = names.stream()
    .filter(name -> name.startsWith("A"))
    .collect(Collectors.toList());
System.out.println(filteredNames);  // 输出 [Alice]

3. Lambda 表达式的特性

3.1 类型推断

在 Lambda 表达式中，参数的类型可以省略，编译器会根据上下文进行推断。

Function<Integer, Integer> square = x -> x * x;  // 类型自动推断

3.2 变量的作用域

Lambda 表达式可以访问其外部作用域中的变量，这种特性被称为闭包。

int factor = 2;
Function<Integer, Integer> multiplier = x -> x * factor;
System.out.println(multiplier.apply(5));  // 输出 10

3.3 不可变性

在 Lambda 表达式中，外部变量必须是“有效的最终变量”或“最终变量”，即在 Lambda 表达式创建后，这些变量的值不能被修改。

final int factor = 2;  // 必须是 final 或者是有效的最终变量
Function<Integer, Integer> multiplier = x -> x * factor;

4. 高级用法

4.1 组合 Lambda 表达式

可以通过方法引用或将多个 Lambda 表达式组合在一起，创建更复杂的操作。

4.1.1 使用方法引用

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(System.out::println);  // 方法引用替代 Lambda

4.2 自定义高阶函数

Lambda 表达式可以作为参数传递，从而实现更灵活的函数组合。

public static void process(List<String> list, Consumer<String> consumer) {
    for (String item : list) {
        consumer.accept(item);
    }
}

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
process(names, name -> System.out.println(name));  // 传递 Lambda 表达式