用好 Lambda 表達式，開發(fā)效率輕松破圈

作者：一安 2025-04-01 08:12:10

Lambda?表達式在Java?編程中應(yīng)用廣泛，熟練掌握這些技巧，能讓你的代碼更簡潔、高效。對于Java?開發(fā)者來說，Lambda?表達式是提升編程能力的關(guān)鍵。希望大家通過本文的學習，能熟練運用Lambda表達式，在開發(fā)中更加得心應(yīng)手！?

前言

在Java編程的世界里，Java 8引入的Lambda表達式堪稱一項重大變革。在它出現(xiàn)之前，Java開發(fā)者在處理集合操作、多線程編程等任務(wù)時，往往要編寫大量繁瑣的樣板代碼，不僅耗時費力，代碼的可讀性和維護性也欠佳。而Lambda表達式的到來，就像給Java編程注入了一針高效強心劑，讓代碼變得簡潔、精煉，極大地提升了開發(fā)效率。

接下來，就為大家詳細介紹10種Lambda表達式在實際工作中極為常用的應(yīng)用場景，幫助大家快速掌握這一強大工具。

案例

集合遍歷：簡化循環(huán)操作

在遍歷集合時，傳統(tǒng)的for - each循環(huán)雖然經(jīng)典，但代碼略顯冗長。使用Lambda表達式，一行代碼就能實現(xiàn)同樣的功能。例如：

import java.util.Arrays;
import java.util.List;

public class LambdaForEach {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        for (int number : numbers) {
            System.out.println("傳統(tǒng)方式遍歷: " + number);
        }
        
        numbers.forEach(number -> System.out.println("Lambda方式遍歷: " + number));
    }
}

集合排序：代碼瘦身，效率提升

對集合進行排序時，傳統(tǒng)方式需要創(chuàng)建一個實現(xiàn)Comparator接口的匿名內(nèi)部類，代碼較為繁瑣。借助Lambda表達式，排序操作變得輕松簡單：

import java.util.Arrays;
import java.util.List;

public class LambdaSort {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(3);
        numbers.add(1);
        numbers.add(2);
        Collections.sort(numbers, new Comparator<Integer>() {
            @Override
            public int compare(Integer num1, Integer num2) {
                return num1 - num2;
            }
        });
        System.out.println("傳統(tǒng)方式排序結(jié)果: " + numbers);
        
        numbers.sort((num1, num2) -> num1 - num2);
        System.out.println("Lambda方式排序結(jié)果: " + numbers);
    }
}

集合過濾：精準篩選所需元素

當需要從集合中篩選出符合特定條件的元素時，Lambda表達式的優(yōu)勢就凸顯出來了。比如，要過濾出以a開頭的字符串：

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

public class LambdaFilter {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>();
        words.add("apple");
        words.add("banana");
        words.add("cherry");
        words.add("apricot");
        List<String> filteredWords = new ArrayList<>();
        for (String word : words) {
            if (word.startsWith("a")) {
                filteredWords.add(word);
            }
        }
        System.out.println("傳統(tǒng)方式過濾結(jié)果: " + filteredWords);
        
        filteredWords = words.stream().filter(word -> word.startsWith("a")).collect(Collectors.toList());
        System.out.println("Lambda方式過濾結(jié)果: " + filteredWords);    
    }
}

映射操作：輕松轉(zhuǎn)換數(shù)據(jù)類型

在將集合中的元素進行類型轉(zhuǎn)換時，Lambda表達式同樣能發(fā)揮重要作用。以將字符串數(shù)字轉(zhuǎn)換為整數(shù)為例：

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

public class LambdaMap {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        List<String> stringNumbers = new ArrayList<>();
        for (int number : numbers) {
            stringNumbers.add(String.valueOf(number));
        }
        System.out.println("傳統(tǒng)方式映射結(jié)果: " + stringNumbers);
        
        stringNumbers = numbers.stream().map(String::valueOf).collect(Collectors.toList());
        System.out.println("Lambda方式映射結(jié)果: " + stringNumbers);
    }
}

計算操作：簡化統(tǒng)計過程

在進行集合元素的求和、求平均值等計算操作時，Lambda表達式能讓代碼變得更加簡潔明了。比如，計算列表中數(shù)字的和與平均值：

import java.util.Arrays;
import java.util.List;
import java.util.OptionalDouble;

public class LambdaReduce {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        int sum = 0;
        for (int number : numbers) {
            sum += number;
        }
        double average = sum / (double) numbers.size();
        System.out.println("傳統(tǒng)方式求和結(jié)果: " + sum);
        System.out.println("傳統(tǒng)方式求平均值結(jié)果: " + average);

        sum = numbers.stream()
                .mapToInt(Integer::intValue)
                .sum();
        OptionalDouble average2 = numbers.stream()
                .mapToInt(Integer::intValue)
                .average();
        System.out.println("Lambda方式求和結(jié)果: " + sum);
        System.out.println("Lambda方式求平均值結(jié)果: " + average2.getAsDouble());
    }
}

分組操作：按條件分類集合元素

對集合元素進行分組時，Lambda表達式結(jié)合Collectors.groupingBy方法，能輕松實現(xiàn)復(fù)雜的分組需求。例如，按字符串長度對列表進行分組：

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class LambdaGrouping {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        Map<Integer, List<Integer>> groupedNumbers = new HashMap<>();
        for (int number : numbers) {
            int remainder = number % 2;
            if (!groupedNumbers.containsKey(remainder)) {
                groupedNumbers.put(remainder, new ArrayList<>());
            }
            groupedNumbers.get(remainder).add(number);
        }
        System.out.println("傳統(tǒng)方式分組結(jié)果: " + groupedNumbers);
        
        groupedNumbers = numbers.stream().collect(Collectors.groupingBy(number -> number % 2));
        System.out.println("Lambda方式分組結(jié)果: " + groupedNumbers);
    }
}

函數(shù)式接口：簡化線程創(chuàng)建

在創(chuàng)建線程時，使用Lambda表達式可以簡化代碼結(jié)構(gòu)。傳統(tǒng)方式創(chuàng)建線程需要實現(xiàn)Runnable接口，代碼較為繁瑣。而Lambda表達式可以讓代碼更加簡潔：

public class LambdaFunctionalInterface {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("傳統(tǒng)方式創(chuàng)建線程");
            }
        };
        new Thread(runnable).start();
        
        Runnable runnable2 = () -> System.out.println("Lambda方式創(chuàng)建線程");
        new Thread(runnable2).start();
    }
}

Optional：優(yōu)雅處理空值

在處理可能為空的值時，Optional類結(jié)合Lambda表達式可以避免繁瑣的空值檢查。例如：

import java.util.Optional;

public class LambdaOptional {
    public static void main(String[] args) {
        Optional<String> optional = Optional.ofNullable(null);
        if (optional.isPresent()) {
            System.out.println("傳統(tǒng)方式Optional值: " + optional.get());
        } else {
            System.out.println("值不存在");
        }

        optional.ifPresent(value -> System.out.println("Lambda方式Optional值: " + value));
    }
}

Stream 流水操作：連貫處理數(shù)據(jù)

在進行復(fù)雜的數(shù)據(jù)處理時，Stream流結(jié)合Lambda表達式可以實現(xiàn)一系列連貫的操作，如過濾、映射、排序等。例如：

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

public class LambdaStream {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>();
        words.add("java");
        words.add("python");
        words.add("c++");
        words.add("javascript");
        List<String> result = new ArrayList<>();
        for (String word : words) {
            if (word.length() > 3) {
                result.add(word.toUpperCase());
            }
        }
        Collections.sort(result, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.compareTo(s2);
            }
        });
        System.out.println("傳統(tǒng)方式Stream操作結(jié)果: " + result);
        
        result = words.stream().filter(word -> word.length() > 3).map(String::toUpperCase).sorted().collect(Collectors.toList());
        System.out.println("Lambda方式Stream操作結(jié)果: " + result);
    }
}

提升可讀性：合理優(yōu)化 Lambda 表達式

雖然Lambda表達式簡潔高效，但在某些復(fù)雜場景下，可能會影響代碼的可讀性。為了改善這一問題，可以為復(fù)雜的Lambda表達式添加注釋，或者將其提取為具有描述性名稱的方法。例如：

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

public class LambdaReadability {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>();
        words.add("java");
        words.add("python");
        words.add("c++");
        words.add("javascript");
        List<String> result = words.stream()
                                   .filter(LambdaReadability::isLongerThanThree)
                                   .map(LambdaReadability::toUpperCaseFirstLetter)
                                   .sorted()
                                   .collect(Collectors.toList());
        System.out.println("提升可讀性的Lambda操作結(jié)果: " + result);
    }

    private static boolean isLongerThanThree(String word) {
        return word.length() > 3;
    }

    private static String toUpperCaseFirstLetter(String word) {
        return word.substring(0, 1).toUpperCase() + word.substring(1);
    }
}

Lambda表達式在Java編程中應(yīng)用廣泛，熟練掌握這些技巧，能讓你的代碼更簡潔、高效。對于Java開發(fā)者來說，Lambda表達式是提升編程能力的關(guān)鍵。希望大家通過本文的學習，能熟練運用Lambda表達式，在開發(fā)中更加得心應(yīng)手！

責任編輯：武曉燕來源：一安未來

Lambda Java?編程