Java值得使用Lambda的8个场景合集
作者：一只叫煤球的猫
前言
可能对不少人来说，Lambda显得陌生又复杂，觉得Lambda会导致代码可读性下降，诟病Lambda语法，甚至排斥。
其实所有的这些问题，在尝试并熟悉后，可能都不是问题。
对Lambda持怀疑态度的人，也许可以采取渐进式使用Lambda的策略。在一些简单和低风险的场景下先尝试使用Lambda，逐渐增加Lambda表达式的使用频率和范围。
毕竟2023年了，JDK都出了那么多新版本，是时候试试Lambda了！
耐心看完，你一定有所收获。
1. 对集合进行遍历和筛选
使用Lambda表达式结合Stream API可以在更少的代码量下实现集合的遍历和筛选，更加简洁和易读。
原来的写法：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
for (Integer num : numbers) {
if (num % 2 == 0) {
System.out.println(num);
}
}优化的Lambda写法：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.stream()
.filter(num -> num % 2 == 0)
.forEach(System.out::println);2. 对集合元素进行排序
使用Lambda表达式可以将排序逻辑以更紧凑的形式传递给sort方法，使代码更加简洁。
原来的写法：
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写法：
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
names.sort((name1, name2) -> name1.compareTo(name2));3. 集合的聚合操作
Lambda表达式结合Stream API可以更优雅地实现对集合元素的聚合操作，例如求和、求平均值等。
原来的写法：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = 0;
for (Integer num : numbers) {
sum += num;
}优化的Lambda写法：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
.reduce(0, Integer::sum);4. 条件过滤和默认值设置
使用Lambda的Optional类可以更加优雅地处理条件过滤和默认值设置的逻辑。
原来的写法：
String name = "Alice";
if (name != null && name.length() > 0) {
System.out.println("Hello, " + name);
} else {
System.out.println("Hello, Stranger");
}Lambda写法：
String name = "Alice";
name = Optional.ofNullable(name)
.filter(n -> n.length() > 0)
.orElse("Stranger");
System.out.println("Hello, " + name);5. 简化匿名内部类
可以简化代码，同时提高代码可读性。
举个创建Thread的例子，传统方式使用匿名内部类来实现线程，语法较为冗长，而Lambda表达式可以以更简洁的方式达到相同的效果。
原来的写法：
new Thread(new Runnable() {
public void run() {
System.out.println("Thread is running.");
}
}).start();Lambda写法：
new Thread(() -> System.out.println("Thread is running.")).start();
new Thread(() -> {
// 做点什么
}).start();这种写法也常用于简化回调函数，再举个例子：
假设我们有一个简单的接口叫做Calculator，它定义了一个单一的方法calculate(int a, int b)来执行数学运算：
// @FunctionalInterface: 标识接口是函数式接口，只包含一个抽象方法，从而能够使用Lambda表达式来实现接口的实例化
@FunctionalInterface
interface Calculator {
int calculate(int a, int b);
}现在，让我们创建一个名为CallbackExample的类。该类有一个名为operate的方法，它接受两个整数和一个Calculator接口作为参数。该方法将使用提供的Calculator接口执行计算并返回结果：
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接口的类，使得代码更加简洁和易读
6. 集合元素的转换
使用Lambda的map方法可以更优雅地对集合元素进行转换，提高代码的可读性
原来的写法：
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> uppercaseNames = new ArrayList<>();
for (String name : names) {
uppercaseNames.add(name.toUpperCase());
}Lambda写法：
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> uppercaseNames = names.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());7. 对集合进行分组和统计
以更紧凑的形式传递分组和统计的逻辑，避免了繁琐的匿名内部类的声明和实现。
通过groupingBy、counting、summingInt等方法，使得代码更加流畅、直观且优雅。
传统写法：
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写法：
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可以方便地进行并行处理，充分利用多核处理器的优势，提高程序的执行效率。
假设我们有一个包含一百万个整数的列表，我们想要计算这些整数的平均值：
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");
}
}分别使用顺序流和并行流来计算列表中整数的平均值：
- 顺序流：通过stream()方法获取流，使用mapToInt将Integer转换为int，然后使用average()方法计算平均值
- 并行流：使用parallelStream()方法获取并行流，其他步骤与顺序流相同
查看输出结果：
Sequential Average: 49.517461
Time taken (Sequential): 10ms
Parallel Average: 49.517461
Time taken (Parallel): 3ms
可以看出，顺序流和并行流得到了相同的平均值，但并行流的处理时间明显少于顺序流。因为并行流能够将任务拆分成多个小任务，并在多个处理器核心上同时执行这些任务。
当然并行流也有缺点：
- 对于较小的数据集，可能并行流更慢
- 数据处理本身的开销较大，比如复杂计算、大量IO操作、网络通信等，可能并行流更慢
- 可能引发线程安全问题
收尾
Lambda的使用场景远不止这些，在多线程、文件操作等场景中也都能灵活运用，一旦熟悉后可以让代码更简洁，实现精准而优雅的编程。
写代码时，改变偏见需要我们勇于尝试和付诸行动。有时候，我们可能会对某种编程语言、框架或设计模式持有偏见，认为它们不适合或不好用。但是，只有尝试去了解和实践，我们才能真正知道它们的优点和缺点。
当我们愿意打破旧有的观念，敢于尝试新的技术和方法时，我们就有机会发现新的可能性和解决问题的新途径。不要害怕失败或犯错，因为每一次尝试都是我们成长和进步的机会。
只要我们保持开放的心态，不断学习和尝试，我们就能够超越偏见，创造出更优秀的代码和解决方案。
所以，让我们在编程的路上，积极地去挑战和改变偏见。用行动去证明，只有不断地尝试，我们才能取得更大的进步和成功。让我们敢于迈出第一步，勇往直前，一同创造出更美好的编程世界！
以上就是Java值得使用Lambda的8个场景合集的详细内容，更多关于Java Lambda的资料请关注脚本之家其它相关文章！