用好 Lambda 表達式，開發效率輕松破圈
作者：一安
Lambda?表達式在Java?編程中應用廣泛，熟練掌握這些技巧，能讓你的代碼更簡潔、高效。對于Java?開發者來說，Lambda?表達式是提升編程能力的關鍵。希望大家通過本文的學習，能熟練運用Lambda表達式，在開發中更加得心應手！?
前言
在Java編程的世界里，Java 8引入的Lambda表達式堪稱一項重大變革。在它出現之前，Java開發者在處理集合操作、多線程編程等任務時，往往要編寫大量繁瑣的樣板代碼，不僅耗時費力，代碼的可讀性和維護性也欠佳。而Lambda表達式的到來，就像給Java編程注入了一針 高效強心劑，讓代碼變得簡潔、精煉，極大地提升了開發效率。
接下來，就為大家詳細介紹10種Lambda表達式在實際工作中極為常用的應用場景，幫助大家快速掌握這一強大工具。
案例
集合遍歷：簡化循環操作
在遍歷集合時，傳統的for - each循環雖然經典，但代碼略顯冗長。使用Lambda表達式，一行代碼就能實現同樣的功能。例如：
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("傳統方式遍歷: " + number);
}
numbers.forEach(number -> System.out.println("Lambda方式遍歷: " + number));
}
}集合排序：代碼瘦身，效率提升
對集合進行排序時，傳統方式需要創建一個實現Comparator接口的匿名內部類，代碼較為繁瑣。借助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("傳統方式排序結果: " + numbers);
numbers.sort((num1, num2) -> num1 - num2);
System.out.println("Lambda方式排序結果: " + numbers);
}
}集合過濾：精準篩選所需元素
當需要從集合中篩選出符合特定條件的元素時，Lambda表達式的優勢就凸顯出來了。比如，要過濾出以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("傳統方式過濾結果: " + filteredWords);
filteredWords = words.stream().filter(word -> word.startsWith("a")).collect(Collectors.toList());
System.out.println("Lambda方式過濾結果: " + filteredWords);
}
}映射操作：輕松轉換數據類型
在將集合中的元素進行類型轉換時，Lambda表達式同樣能發揮重要作用。以將字符串數字轉換為整數為例：
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("傳統方式映射結果: " + stringNumbers);
stringNumbers = numbers.stream().map(String::valueOf).collect(Collectors.toList());
System.out.println("Lambda方式映射結果: " + stringNumbers);
}
}計算操作：簡化統計過程
在進行集合元素的求和、求平均值等計算操作時，Lambda表達式能讓代碼變得更加簡潔明了。比如，計算列表中數字的和與平均值：
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("傳統方式求和結果: " + sum);
System.out.println("傳統方式求平均值結果: " + average);
sum = numbers.stream()
.mapToInt(Integer::intValue)
.sum();
OptionalDouble average2 = numbers.stream()
.mapToInt(Integer::intValue)
.average();
System.out.println("Lambda方式求和結果: " + sum);
System.out.println("Lambda方式求平均值結果: " + average2.getAsDouble());
}
}分組操作：按條件分類集合元素
對集合元素進行分組時，Lambda表達式結合Collectors.groupingBy方法，能輕松實現復雜的分組需求。例如，按字符串長度對列表進行分組：
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("傳統方式分組結果: " + groupedNumbers);
groupedNumbers = numbers.stream().collect(Collectors.groupingBy(number -> number % 2));
System.out.println("Lambda方式分組結果: " + groupedNumbers);
}
}函數式接口：簡化線程創建
在創建線程時，使用Lambda表達式可以簡化代碼結構。傳統方式創建線程需要實現Runnable接口，代碼較為繁瑣。而Lambda表達式可以讓代碼更加簡潔：
public class LambdaFunctionalInterface {
public static void main(String[] args) {
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("傳統方式創建線程");
}
};
new Thread(runnable).start();
Runnable runnable2 = () -> System.out.println("Lambda方式創建線程");
new Thread(runnable2).start();
}
}Optional：優雅處理空值
在處理可能為空的值時，Optional類結合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("傳統方式Optional值: " + optional.get());
} else {
System.out.println("值不存在");
}
optional.ifPresent(value -> System.out.println("Lambda方式Optional值: " + value));
}
}Stream 流水操作：連貫處理數據
在進行復雜的數據處理時，Stream流結合Lambda表達式可以實現一系列連貫的操作，如過濾、映射、排序等。例如：
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("傳統方式Stream操作結果: " + result);
result = words.stream().filter(word -> word.length() > 3).map(String::toUpperCase).sorted().collect(Collectors.toList());
System.out.println("Lambda方式Stream操作結果: " + result);
}
}提升可讀性：合理優化 Lambda 表達式
雖然Lambda表達式簡潔高效，但在某些復雜場景下，可能會影響代碼的可讀性。為了改善這一問題，可以為復雜的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操作結果: " + 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編程中應用廣泛，熟練掌握這些技巧，能讓你的代碼更簡潔、高效。對于Java開發者來說，Lambda表達式是提升編程能力的關鍵。希望大家通過本文的學習，能熟練運用Lambda表達式，在開發中更加得心應手！
責任編輯：武曉燕
來源：
一安未來
