JAVA中的lambda表达式-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_55021218/article/details/145715638

Lambda 表达式是 Java 8 引入的一项重要特性，允许你以一种更简洁和灵活的方式表示 函数式接口（Functional Interface） 的实例。简而言之，Lambda 表达式提供了一种简化匿名内部类写法的方式，尤其是在传递行为（如方法或函数）时非常有用。它使代码更加简洁、清晰，并提高了可读性。

1. Lambda 表达式的基本语法

Lambda 表达式的语法如下：

(parameters) -> expression

parameters：Lambda 表达式的输入参数，类似于方法的参数列表。它可以有多个参数，也可以没有参数。
->：箭头操作符，分隔参数和 Lambda 表达式体。
expression：Lambda 表达式的主体，可以是一个简单的表达式，或者一个包含多条语句的代码块。

2. Lambda 表达式的构成

Lambda 表达式通常由以下三个部分构成：

参数列表：表示 Lambda 表达式接收的输入参数。
箭头 ->：用于将参数列表和方法体分隔开。
方法体：定义 Lambda 表达式的具体行为。方法体可以是一个表达式（如果是单行代码）或者一个语句块。

3. Lambda 表达式的例子

例子 1：无参数，单一表达式

() -> System.out.println("Hello, Lambda!");

这个 Lambda 表达式没有参数，直接输出 "Hello, Lambda!"。

例子 2：一个参数，单一表达式

x -> x * x

这是一个 Lambda 表达式，接收一个参数 x，返回 x 的平方。

例子 3：多个参数，表达式体

(x, y) -> x + y

这个 Lambda 表达式接收两个参数 x 和 y，并返回它们的和。

例子 4：多个参数，包含语句块

(x, y) -> {
    int sum = x + y;
    return sum;
}

这个 Lambda 表达式接收两个参数 x 和 y，计算它们的和并返回。由于有多个语句，所以必须使用大括号 {} 包裹语句，并且使用 return 返回结果。

4. Lambda 表达式与匿名内部类的对比

Lambda 表达式的一个重要应用场景是替代传统的匿名内部类，特别是在实现接口时。以传统的匿名内部类为例：

使用匿名内部类：

Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running using anonymous class");
    }
};
new Thread(runnable).start();

使用 Lambda 表达式：

Runnable runnable = () -> System.out.println("Running using Lambda");
new Thread(runnable).start();

可以看到，Lambda 表达式使得代码更加简洁，去除了冗余的类定义和方法实现。

5. 函数式接口（Functional Interface）

Lambda 表达式必须用于实现 函数式接口。一个函数式接口是指只包含一个抽象方法的接口，但它可以包含多个默认方法或静态方法。Java 8 中的 java.util.function 包包含了大量的内置函数式接口，如 Runnable、Callable、Comparator、Consumer、Supplier 等。

举个例子：一个简单的函数式接口

@FunctionalInterface
public interface MyFunction {
    int add(int a, int b);  // 只定义一个抽象方法
}

可以用 Lambda 表达式实现这个接口：

MyFunction addFunction = (a, b) -> a + b;
System.out.println(addFunction.add(2, 3));  // 输出 5

6. Lambda 表达式的常见使用场景

1. 集合操作

Lambda 表达式常常与 Java 8 引入的 Stream API 一起使用，用于对集合进行更简洁的处理。

例如，使用 Lambda 表达式对一个 List 中的数字进行求和：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream().mapToInt(Integer::intValue).sum();
System.out.println("Sum: " + sum);  // 输出 Sum: 15

`这里的.mapToInt(Integer::intValue)` 是流操作中的一个中间操作。它将流中的 `Integer` 类型元素转换为原始的 `int` 类型元素。`Integer::intValue` 是一个方法引用，它相当于 `x -> x.intValue()`，即对 `Integer` 对象调用 `intValue()` 方法，得到对应的原始 `int` 类型值。

2. 排序

使用 Lambda 表达式对集合进行排序，比传统的匿名内部类方式更简洁。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Collections.sort(names, (s1, s2) -> s1.compareTo(s2));
System.out.println(names);  // 输出 [Alice, Bob, Charlie]

3. 事件监听

在 GUI 编程中，Lambda 表达式常用于简化事件监听器的实现：

button.addActionListener(e -> System.out.println("Button clicked!"));

7. Java 内置函数式接口

Java 8 引入了许多内置的函数式接口，常用的有：

Consumer<T>：表示一个接受一个参数并执行某种操作的操作。

Consumer<String> consumer = s -> System.out.println(s);
consumer.accept("Hello");

Supplier<T>：表示一个没有输入参数，但返回某个结果的操作。

Supplier<String> supplier = () -> "Hello, Lambda!";
System.out.println(supplier.get());  // 输出 "Hello, Lambda!"

Function<T, R>：表示接受一个参数并返回一个结果的操作。

Function<Integer, String> function = i -> "Number: " + i;
System.out.println(function.apply(5));  // 输出 "Number: 5"

Predicate<T>：表示一个接受一个参数并返回布尔值的操作。

Predicate<Integer> isEven = x -> x % 2 == 0;
System.out.println(isEven.test(4));  // 输出 true

8. Lambda 表达式的优势

简洁性：Lambda 表达式使得代码更简洁，减少了冗余代码，尤其是匿名内部类的使用。
可读性：通过清晰的表达式形式，Lambda 使得函数式编程更直观。
延迟计算（惰性求值）：与传统的循环或条件语句相比，Lambda 表达式可以通过流式处理来实现延迟计算。
并行化支持：与 Stream API 结合使用时，Lambda 表达式可以方便地启用并行流处理，提高性能。

9. Lambda 表达式的限制

只适用于函数式接口：Lambda 只能用于函数式接口，即接口中只能有一个抽象方法。
没有方法体：Lambda 表达式中的方法体必须是一个表达式或语句块，不能有其他逻辑控制。
调试困难：由于 Lambda 表达式没有名称，它们在调试时可能不如常规方法清晰。

10. 总结

Lambda 表达式是 Java 8 中的一个强大功能，它支持函数式编程风格，让我们能够更加简洁和灵活地处理集合操作、事件监听、线程等任务。通过简化匿名内部类的写法，Lambda 提高了代码的可读性和可维护性。