值得使用Lambda的8个场景，别再排斥它了！_在哪些场景下可以使用lambda函数?-CSDN博客

本文链接：https://blog.csdn.net/x275920/article/details/134334105

前言

可能对不少人来说，Lambda显得陌生又复杂，觉得Lambda会导致代码可读性下降，诟病Lambda语法，甚至排斥。

其实所有的这些问题，在尝试并熟悉后，可能都不是问题。

对Lambda持怀疑态度的人，也许可以采取渐进式使用Lambda的策略。在一些简单和低风险的场景下先尝试使用Lambda，逐渐增加Lambda表达式的使用频率和范围。

毕竟2023年了，JDK都出了那么多新版本，是时候试试Lambda了！

耐心看完，你一定有所收获。

添加图片注释，不超过 140 字（可选）

正文

1. 对集合进行遍历和筛选：

使用Lambda表达式结合Stream API可以在更少的代码量下实现集合的遍历和筛选，更加简洁和易读。

原来的写法：

java复制代码List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); for (Integer num : numbers) { if (num % 2 == 0) { System.out.println(num); } }

优化的Lambda写法：

java复制代码List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); numbers.stream() .filter(num -> num % 2 == 0) .forEach(System.out::println);

2. 对集合元素进行排序：

使用Lambda表达式可以将排序逻辑以更紧凑的形式传递给sort方法，使代码更加简洁。

原来的写法：

java复制代码List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David"); Collections.sort(names, new Comparator<String>() { public int compare(String name1, String name2) { return name1.compareTo(name2); } });

优化的Lambda写法：

java复制代码List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David"); names.sort((name1, name2) -> name1.compareTo(name2));

3. 集合的聚合操作：

Lambda表达式结合Stream API可以更优雅地实现对集合元素的聚合操作，例如求和、求平均值等。

原来的写法：

java复制代码List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); int sum = 0; for (Integer num : numbers) { sum += num; }

优化的Lambda写法：

java复制代码List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); int sum = numbers.stream() .reduce(0, Integer::sum);

4. 条件过滤和默认值设置：

使用Lambda的Optional类可以更加优雅地处理条件过滤和默认值设置的逻辑。

原来的写法：

java复制代码String name = "Alice"; if (name != null && name.length() > 0) { System.out.println("Hello, " + name); } else { System.out.println("Hello, Stranger"); }

Lambda写法：

java复制代码String name = "Alice"; name = Optional.ofNullable(name) .filter(n -> n.length() > 0) .orElse("Stranger"); System.out.println("Hello, " + name);

5. 简化匿名内部类：

可以简化代码，同时提高代码可读性。

举个创建Thread的例子，传统方式使用匿名内部类来实现线程，语法较为冗长，而Lambda表达式可以以更简洁的方式达到相同的效果。

原来的写法：

java复制代码new Thread(new Runnable() { public void run() { System.out.println("Thread is running."); } }).start();

Lambda写法：

java复制代码new Thread(() -> System.out.println("Thread is running.")).start(); new Thread(() -> { // 做点什么 }).start();

这种写法也常用于简化回调函数，再举个例子：

假设我们有一个简单的接口叫做Calculator，它定义了一个单一的方法calculate(int a, int b)来执行数学运算：

java复制代码// @FunctionalInterface: 标识接口是函数式接口，只包含一个抽象方法，从而能够使用Lambda表达式来实现接口的实例化 @FunctionalInterface interface Calculator { int calculate(int a, int b); }

现在，让我们创建一个名为CallbackExample的类。该类有一个名为operate的方法，它接受两个整数和一个Calculator接口作为参数。该方法将使用提供的Calculator接口执行计算并返回结果：

java复制代码public class CallbackExample { public static int operate(int a, int b, Calculator calculator) { return calculator.calculate(a, b); } public static void main(String[] args) { int num1 = 10; int num2 = 5; // 使用Lambda作为回调 int sum = operate(num1, num2, (x, y) -> x + y); int difference = operate(num1, num2, (x, y) -> x - y); int product = operate(num1, num2, (x, y) -> x * y); int division = operate(num1, num2, (x, y) -> x / y); System.out.println("Sum: " + sum); System.out.println("Difference: " + difference); System.out.println("Product: " + product); System.out.println("Division: " + division); } }

通过在方法调用中直接定义计算的行为，我们不再需要为每个运算创建多个实现Calculator接口的类，使得代码更加简洁和易读

添加图片注释，不超过 140 字（可选）

6. 集合元素的转换：

使用Lambda的map方法可以更优雅地对集合元素进行转换，提高代码的可读性

原来的写法：

java复制代码List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); List<String> uppercaseNames = new ArrayList<>(); for (String name : names) { uppercaseNames.add(name.toUpperCase()); }

Lambda写法：

java复制代码List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); List<String> uppercaseNames = names.stream() .map(String::toUpperCase) .collect(Collectors.toList());

7. 对集合进行分组和统计：

以更紧凑的形式传递分组和统计的逻辑，避免了繁琐的匿名内部类的声明和实现。

通过groupingBy、counting、summingInt等方法，使得代码更加流畅、直观且优雅。

传统写法：

java复制代码 List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Amy", "Diana"); // 对名字长度进行分组 Map<Integer, List<String>> namesByLength = new HashMap<>(); for (String name : names) { int length = name.length(); if (!namesByLength.containsKey(length)) { namesByLength.put(length, new ArrayList<>()); } namesByLength.get(length).add(name); } System.out.println("Names grouped by length: " + namesByLength); // 统计名字中包含字母'A'的个数 List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Amy", "Diana"); int namesWithA = 0; for (String name : names) { if (name.contains("A")) { namesWithA++; } } System.out.println("Number of names containing 'A': " + namesWithA);

Lambda写法：

java复制代码List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Amy", "Diana"); // 使用Lambda表达式对名字长度进行分组 Map<Integer, List<String>> namesByLength = names.stream() .collect(Collectors.groupingBy(String::length)); System.out.println("Names grouped by length: " + namesByLength); // 使用Lambda表达式统计名字中包含字母'A'的个数 long namesWithA = names.stream() .filter(name -> name.contains("A")) .count(); System.out.println("Number of names containing 'A': " + namesWithA);

8. 对大数据量集合的并行处理

当集合的数据量很大时，通过Lambda结合Stream API可以方便地进行并行处理，充分利用多核处理器的优势，提高程序的执行效率。

假设我们有一个包含一百万个整数的列表，我们想要计算这些整数的平均值：

java复制代码import java.util.ArrayList; import java.util.List; import java.util.concurrent.ThreadLocalRandom; public class ParallelStreamExample { public static void main(String[] args) { // 创建一个包含一百万个随机整数的列表 List<Integer> numbers = new ArrayList<>(); for (int i = 0; i < 1000000; i++) { numbers.add(ThreadLocalRandom.current().nextInt(100)); } // 顺序流的处理 long startTimeSeq = System.currentTimeMillis(); double averageSequential = numbers.stream() .mapToInt(Integer::intValue) .average() .getAsDouble(); long endTimeSeq = System.currentTimeMillis(); System.out.println("Sequential Average: " + averageSequential); System.out.println("Time taken (Sequential): " + (endTimeSeq - startTimeSeq) + "ms"); // 并行流的处理 long startTimePar = System.currentTimeMillis(); double averageParallel = numbers.parallelStream() .mapToInt(Integer::intValue) .average() .getAsDouble(); long endTimePar = System.currentTimeMillis(); System.out.println("Parallel Average: " + averageParallel); System.out.println("Time taken (Parallel): " + (endTimePar - startTimePar) + "ms"); } }

分别使用顺序流和并行流来计算列表中整数的平均值：