Java值得使用Lambda的8個場景合集

更新時間：2023年08月04日 14:25:40 作者：一只叫煤球的貓

可能對不少人來說，Lambda顯得陌生又復雜，覺得Lambda會導致代碼可讀性下降，但畢竟2023年了，JDK都出了那么多新版本，是時候試試Lambda了

前言

可能對不少人來說，Lambda顯得陌生又復雜，覺得Lambda會導致代碼可讀性下降，詬病Lambda語法，甚至排斥。

其實所有的這些問題，在嘗試并熟悉后，可能都不是問題。

對Lambda持懷疑態(tài)度的人，也許可以采取漸進式使用Lambda的策略。在一些簡單和低風險的場景下先嘗試使用Lambda，逐漸增加Lambda表達式的使用頻率和范圍。

畢竟2023年了，JDK都出了那么多新版本，是時候試試Lambda了！

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

1. 對集合進行遍歷和篩選

使用Lambda表達式結(jié)合Stream API可以在更少的代碼量下實現(xiàn)集合的遍歷和篩選，更加簡潔和易讀。

原來的寫法：

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

優(yōu)化的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);
    }
});

優(yōu)化的Lambda寫法：

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

3. 集合的聚合操作

Lambda表達式結(jié)合Stream API可以更優(yōu)雅地實現(xiàn)對集合元素的聚合操作，例如求和、求平均值等。

原來的寫法：

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

優(yōu)化的Lambda寫法：

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

4. 條件過濾和默認值設(shè)置

使用Lambda的Optional類可以更加優(yōu)雅地處理條件過濾和默認值設(shè)置的邏輯。

原來的寫法：

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. 簡化匿名內(nèi)部類

可以簡化代碼，同時提高代碼可讀性。

舉個創(chuàng)建Thread的例子，傳統(tǒng)方式使用匿名內(nèi)部類來實現(xiàn)線程，語法較為冗長，而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();

這種寫法也常用于簡化回調(diào)函數(shù)，再舉個例子：

假設(shè)我們有一個簡單的接口叫做Calculator，它定義了一個單一的方法calculate(int a, int b)來執(zhí)行數(shù)學運算：

// @FunctionalInterface: 標識接口是函數(shù)式接口，只包含一個抽象方法，從而能夠使用Lambda表達式來實現(xiàn)接口的實例化
@FunctionalInterface 
interface Calculator {
    int calculate(int a, int b);
}

現(xiàn)在，讓我們創(chuàng)建一個名為CallbackExample的類。該類有一個名為operate的方法，它接受兩個整數(shù)和一個Calculator接口作為參數(shù)。該方法將使用提供的Calculator接口執(zhí)行計算并返回結(jié)果：

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作為回調(diào)
        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);
    }
}

通過在方法調(diào)用中直接定義計算的行為，我們不再需要為每個運算創(chuàng)建多個實現(xiàn)Calculator接口的類，使得代碼更加簡潔和易讀

6. 集合元素的轉(zhuǎn)換

使用Lambda的map方法可以更優(yōu)雅地對集合元素進行轉(zhuǎn)換，提高代碼的可讀性

原來的寫法：

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. 對集合進行分組和統(tǒng)計

以更緊湊的形式傳遞分組和統(tǒng)計的邏輯，避免了繁瑣的匿名內(nèi)部類的聲明和實現(xiàn)。

通過groupingBy、counting、summingInt等方法，使得代碼更加流暢、直觀且優(yōu)雅。

傳統(tǒng)寫法：

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);
// 統(tǒng)計名字中包含字母'A'的個數(shù)
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表達式統(tǒng)計名字中包含字母'A'的個數(shù)
long namesWithA = names.stream()
        .filter(name -> name.contains("A"))
        .count();
System.out.println("Number of names containing 'A': " + namesWithA);

8. 對大數(shù)據(jù)量集合的并行處理

當集合的數(shù)據(jù)量很大時，通過Lambda結(jié)合Stream API可以方便地進行并行處理，充分利用多核處理器的優(yōu)勢，提高程序的執(zhí)行效率。

假設(shè)我們有一個包含一百萬個整數(shù)的列表，我們想要計算這些整數(shù)的平均值：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
public class ParallelStreamExample {
    public static void main(String[] args) {
        // 創(chuàng)建一個包含一百萬個隨機整數(shù)的列表
        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");
    }
}

分別使用順序流和并行流來計算列表中整數(shù)的平均值：