Lambda 表达式-CSDN博客

本文链接：https://blog.csdn.net/LIUCHANGSHUO/article/details/140693085

简述：

Lambda 表达式（lambda expression）是一个匿名函数，它基于数学中的λ演算得名，直接对应于其中的 lambda 抽象（lambda abstraction），即没有函数名的函数。Lambda 表达式可以表示闭包（注意和数学传统意义上的不同）。

Lambda 表达式 是 Java 8 引入的一种新的编程特性，用于创建简洁的匿名函数。

解决的问题：

Lambda 表达式主要解决了以下几类问题：

代码简洁性
- 减少了冗长的匿名内部类的使用，使代码更加简洁易读。例如，在实现简单的事件监听器或回调函数时，无需再创建一个完整的类来实现接口。
增强函数式编程能力
- 让 Java 能够更好地支持函数式编程风格，将函数作为一等公民，可以更方便地传递和操作函数。
提高代码的可读性和可维护性
- 对于一些简单的逻辑，直接在使用的地方定义函数，而不是在其他地方单独实现一个类，使代码的逻辑更加集中和清晰。
便于并行处理
- 结合 Java 8 的 Stream 流，可以更轻松地实现并行计算，提高程序的性能。
更好地处理集合数据
- 能够更简洁地对集合进行过滤、映射、排序等操作，使集合处理的代码更加直观。

应用场景：

Lambda 表达式在 Java 中有广泛的应用场景，以下是一些常见的例子：

集合操作：
- 对集合进行遍历，例如：

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

过滤集合元素，比如筛选出长度大于 5 的字符串：

      List<String> filteredNames = names.stream()
        .filter(name -> name.length() > 5)
        .collect(Collectors.toList());

线程创建：

    new Thread(() -> System.out.println("Thread is running")).start();

事件处理：
- 在图形用户界面（GUI）编程中，处理按钮点击等事件。

比较器（Comparator）：

    List<Person> people =...;
    people.sort((p1, p2) -> p1.getAge() - p2.getAge());

Stream 流的中间操作和终端操作：
- 映射操作，将一个元素转换为另一个元素。
- 归约操作，计算集合元素的总和、平均值等。
函数式接口的实现：
- 自定义的函数式接口，然后通过 Lambda 表达式来实现其抽象方法。
并行处理：
- 利用并行流提高处理大规模数据的效率。
定时任务：
- 在定时任务框架（如 ScheduledExecutorService ）中定义执行的逻辑。

实例讲解：

例如，使用传统方式实现一个接口方法可能像这样：

interface MathOperation {
    int operate(int a, int b);
}

class Addition implements MathOperation {
    @Override
    public int operate(int a, int b) {
        return a + b;
    }
}

而使用 Lambda 表达式可以这样写：

MathOperation addition = (a, b) -> a + b;

在集合操作中，比如遍历一个列表：传统方式：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
for (String name : names) {
    System.out.println(name);
}

使用 Lambda 表达式和 Stream API：

names.stream().forEach(name -> System.out.println(name));

以下通过几个实例来详细讲解 Lambda 表达式的应用：

实例 1：集合遍历 使用 forEach 方法结合 Lambda 表达式遍历了水果列表并打印每个元素。

import java.util.ArrayList;
import java.util.List;

public class CollectionTraversalExample {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // 使用 Lambda 表达式遍历集合
        fruits.forEach(fruit -> System.out.println(fruit));
    }
}

实例 2：集合过滤 这里通过 stream 流和 filter 方法结合 Lambda 表达式筛选出了偶数，并将结果收集到新的列表中进行打印。

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class CollectionFilteringExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);

        // 使用 Lambda 表达式过滤出偶数
        List<Integer> evenNumbers = numbers.stream()
              .filter(num -> num % 2 == 0)
              .collect(Collectors.toList());

        evenNumbers.forEach(num -> System.out.println(num));
    }
}

实例 3：自定义函数式接口 在这个例子中，自定义了一个函数式接口 CustomOperation ，然后使用 Lambda 表达式实现了其方法来进行乘以 2 的操作。

import java.util.function.Function;

public class CustomFunctionalInterfaceExample {

    interface CustomOperation {
        int perform(int num);
    }

    public static void main(String[] args) {
        CustomOperation doubleOperation = num -> num * 2;

        int result = doubleOperation.perform(5);
        System.out.println("Double of 5 is: " + result);
    }
}