前言

可能对不少人来说，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的使用场景远不止这些，在多线程、文件操作等场景中也都能灵活运用，一旦熟悉后可以让代码更简洁，实现精准而优雅的编程。

写代码时，改变偏见需要我们勇于尝试和付诸行动。有时候，我们可能会对某种编程语言、框架或设计模式持有偏见，认为它们不适合或不好用。但是，只有尝试去了解和实践，我们才能真正知道它们的优点和缺点。

当我们愿意打破旧有的观念，敢于尝试新的技术和方法时，我们就有机会发现新的可能性和解决问题的新途径。不要害怕失败或犯错，因为每一次尝试都是我们成长和进步的机会。

只要我们保持开放的心态，不断学习和尝试，我们就能够超越偏见，创造出更优秀的代码和解决方案。

所以，让我们在编程的路上，积极地去挑战和改变偏见。用行动去证明，只有不断地尝试，我们才能取得更大的进步和成功。让我们敢于迈出第一步，勇往直前，一同创造出更美好的编程世界！