Lambda表達式是Java 8中引入的一個重要特性，它允許開發(fā)者以更加簡潔的方式編寫函數(shù)式代碼。在本文中，我們將深入探討Lambda表達式的概念、語法和用法，并為每個實例提供代碼演示，同時對比與傳統(tǒng)方法的區(qū)別和優(yōu)勢。

1. Lambda表達式概述

Lambda表達式是一種匿名函數(shù)，它主要用于表示簡單的行為或代碼塊，并可以在需要時傳遞到其他函數(shù)中。Lambda表達式可以看作是一個函數(shù)式接口的實例，它由三個部分組成：參數(shù)列表、箭頭符號和表達式體。以下是一個簡單的Lambda表達式示例：

() -> System.out.println("Hello, World!");

在這個示例中，Lambda表達式包含一個空參數(shù)列表，箭頭符號"->"和一個輸出"Hello, World!"的表達式體。它可以通過調(diào)用Lambda表達式的函數(shù)式接口來執(zhí)行。

2. Lambda表達式語法

Lambda表達式的語法非常簡單，它由三個部分組成：參數(shù)列表、箭頭符號和表達式體。以下是Lambda表達式的語法：

(parameters) -> expression

或者

(parameters) -> { statements; }

其中，參數(shù)列表可以是空的、包含一個參數(shù)或包含多個參數(shù)。如果有多個參數(shù)，則需要使用逗號分隔參數(shù)。表達式體可以是一個簡單的表達式，也可以是一個代碼塊。

當使用Java語言時，Lambda表達式也由三個關(guān)鍵部分組成：

參數(shù)列表：指定Lambda函數(shù)接受的參數(shù)。參數(shù)可以有零到多個，用逗號隔開，放在小括號中。

箭頭符號：箭頭符號“->”用于分隔參數(shù)列表和表達式體。它表示將給定的參數(shù)映射到表達式體中進行計算。

表達式體：指定Lambda函數(shù)執(zhí)行的代碼塊，可以是任何有效的表達式或語句塊。

下面是一個簡單的示例，展示了一個使用Lambda表達式來對字符串數(shù)組進行排序的例子：

// 對字符串數(shù)組進行排序
String[] myArray = {"hello", "world", "lambda", "expression"};

// 使用Lambda表達式定義排序規(guī)則
Arrays.sort(myArray, (String str1, String str2) -> str1.compareTo(str2));

// 輸出排序后的結(jié)果
System.out.println(Arrays.toString(myArray));

在這個例子中，Lambda表達式被用作Comparator的實現(xiàn)傳遞給Arrays.sort方法。Lambda表達式(String str1, String str2) -> str1.compareTo(str2)指定了排序規(guī)則，它接受兩個參數(shù)str1和str2，并返回它們比較的結(jié)果。這意味著該字符串數(shù)組將按字母序進行排序。

需要注意的是，Lambda表達式需要使用函數(shù)式接口來實現(xiàn)。函數(shù)式接口是一個只有一個抽象方法的接口，它可以被Lambda表達式實現(xiàn)。Java 8提供了許多內(nèi)置的函數(shù)式接口，例如Comparator、Runnable和Function等。

3. Lambda表達式用法

Lambda表達式的主要用途是作為函數(shù)式接口的

提供了一些demo;

1.遍歷列表并輸出每個元素

List<String> list = Arrays.asList("apple", "banana", "orange");

// 使用Lambda遍歷列表
list.forEach(item -> System.out.println(item));

// 常規(guī)寫法
for (String item : list) {
    System.out.println(item);
}

2.篩選列表中的偶數(shù)并返回一個新列表

List list = Arrays.asList(1, 2, 3, 4, 5, 6);

// 使用Lambda篩選偶數(shù)

List<Integer> evenList = list.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());
System.out.println(evenList);

// 常規(guī)寫法
List<Integer> evenList2 = new ArrayList<>();
for (Integer num : list) {
    if (num % 2 == 0) {
        evenList2.add(num);
    }
}
System.out.println(evenList2);

3.將字符串轉(zhuǎn)換為大寫并返回一個新列表

List<String> list = Arrays.asList("apple", "banana", "orange");

// 使用Lambda將字符串轉(zhuǎn)換為大寫


List<String> upperList = list.stream().map(str -> str.toUpperCase()).collect(Collectors.toList());
System.out.println(upperList);

// 常規(guī)寫法
List<String> upperList2 = new ArrayList<>();
for (String str : list) {
    upperList2.add(str.toUpperCase());
}
System.out.println(upperList2);

4.計算列表中所有元素的總和

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

// 使用Lambda計算列表元素總和
int sum = list.stream().reduce(0, (a, b) -> a + b);
System.out.println(sum);

// 常規(guī)寫法
int sum2 = 0;
for (Integer num : list) {
    sum2 += num;
}
System.out.println(sum2);

5.將列表中的元素轉(zhuǎn)換為鍵值對并放入Map中

List<String> list = Arrays.asList("apple", "banana", "orange");

// 使用Lambda將列表中的元素轉(zhuǎn)換為鍵值對并放入Map中
Map<String, Integer> map = list.stream().collect(Collectors.toMap(Function.identity(), String::length));
System.out.println(map);

// 常規(guī)寫法
Map<String, Integer> map2 = new HashMap<>();
for (String str : list) {
    map2.put(str, str.length());
}
System.out.println(map2);

6. 篩選集合中的元素

// 使用Lambda表達式篩選出小于10的數(shù)字
List<Integer> numbers = Arrays.asList(1, 5, 10, 15);
List<Integer> filteredNumbers = numbers.stream()
                                        .filter(n -> n < 10)
                                        .collect(Collectors.toList());

// 傳統(tǒng)寫法
List<Integer> filteredNumbers = new ArrayList<>();
for (Integer n : numbers) {
    if (n < 10) {
        filteredNumbers.add(n);
    }
}

7. 在集合中進行映射

// 使用Lambda表達式將字符串轉(zhuǎn)換為它們的長度
List<String> words = Arrays.asList("apple", "banana", "orange");
List<Integer> wordLengths = words.stream()
                                 .map(s -> s.length())
                                 .collect(Collectors.toList());

// 傳統(tǒng)寫法
List<Integer> wordLengths = new ArrayList<>();
for (String s : words) {
    wordLengths.add(s.length());
}

8.對集合中的元素進行排序

// 使用Lambda表達式將集合中的元素按字母順序排序
List<String> words = Arrays.asList("apple", "banana", "orange");
Collections.sort(words, (s1, s2) -> s1.compareTo(s2));

// 傳統(tǒng)寫法
List<String> words = Arrays.asList("apple", "banana", "orange");
Collections.sort(words, new Comparator<String>() {
    public int compare(String s1, String s2) {
        return s1.compareTo(s2);
    }
});

9.執(zhí)行多個操作

// 使用Lambda表達式執(zhí)行多個操作
List<String> words = Arrays.asList("apple", "banana", "orange");
words.stream()
     .filter(s -> s.startsWith("a"))
     .map(s -> s.toUpperCase())
     .forEach(System.out::println);

// 傳統(tǒng)寫法
List<String> words = Arrays.asList("apple", "banana", "orange");
for (String s : words) {
    if (s.startsWith("a")) {
        System.out.println(s.toUpperCase());
    }
}

10.對整數(shù)數(shù)組進行排序

//傳統(tǒng)寫法：

int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5};
Arrays.sort(arr, new Comparator<Integer>() {
    public int compare(Integer a, Integer b) {
        return a - b;
    }
});

//Lambda寫法：

int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5};
Arrays.sort(arr, (a, b) -> a - b);

說明：這個示例展示了如何使用Lambda表達式對一個整數(shù)數(shù)組進行排序。在傳統(tǒng)寫法中，我們需要定義一個實現(xiàn)Comparator接口的類，并在排序時將其傳遞給Arrays.sort()方法。而在Lambda寫法中，我們只需要編寫一行簡單的代碼即可完成相同的操作。

11使用Stream API過濾集合元素

//傳統(tǒng)寫法：

List<String> list = Arrays.asList("apple", "banana", "cherry", "date");
List<String> filteredList = new ArrayList<>();
for (String s : list) {
    if (s.startsWith("a")) {
        filteredList.add(s);
    }
}

//Lambda寫法：

List<String> list = Arrays.asList("apple", "banana", "cherry", "date");
List<String> filteredList = list.stream()
    .filter(s -> s.startsWith("a"))
    .collect(Collectors.toList());

說明：這個示例展示了如何使用Lambda表達式和Stream API對一個字符串列表進行過濾。在傳統(tǒng)寫法中，我們需要手動遍歷整個集合并篩選出符合條件的元素，而在Lambda寫法中，我們可以使用stream()方法將集合轉(zhuǎn)換為流，并使用filter()方法對流進行過濾操作。

12. 使用Lambda表達式作為方法參數(shù)

//傳統(tǒng)寫法：

public static void operate(int a, int b, Operation operation) {
    System.out.println(operation.operate(a, b));
}

interface Operation {
    int operate(int a, int b);
}

operate(2, 3, new Operation() {
    public int operate(int a, int b) {
        return a + b;
    }
});

//Lambda寫法：

public static void operate(int a, int b, IntBinaryOperator operator) {
    System.out.println(operator.applyAsInt(a, b));
}

operate(2, 3, (a, b) -> a + b);

說明：這個示例展示了如何使用Lambda表達式作為方法參數(shù)。在傳統(tǒng)寫法中，我們需要定義一個實現(xiàn)某個接口的類，并在調(diào)用方法時將其傳遞給方法。而在Lambda寫法中，我們可以直接在調(diào)用方法時編寫Lambda表達式作為參數(shù)，從而省略了額外的類定義。

13.使用Lambda表達式作為變量

//傳統(tǒng)寫法：

public static void printMessage(String message) {
    System.out.println(message);
}

printMessage("Hello, world!");

//Lambda寫法：

Consumer<String> printer = (message) -> System.out.println(message);
printer.accept("Hello, world!");

說明：這個示例展示了如何使用Lambda表達式定義一個函數(shù)式接口的實現(xiàn)，并將其作為變量使用。在傳統(tǒng)寫法中，我們需要定義一個方法并在調(diào)用時傳遞參數(shù)。而在Lambda寫法中，我們可以先定義一個函數(shù)式接口，然后使用Lambda表達式創(chuàng)建其實現(xiàn)，并將其賦值給一個變量。

4.Lambda表達式優(yōu)缺點

Lambda表達式具有以下優(yōu)點：

簡潔：使用Lambda表達式可以少寫很多樣板代碼。
靈活：Lambda表達式可以在運行時定義，在需要時才創(chuàng)建。
易讀：Lambda表達式的語法簡單明了，易于理解。

Lambda表達式也具有以下缺點：

可讀性：過度使用Lambda表達式可能會降低代碼的可讀性。
性能：Lambda表達式的性能可能比普通方法略差。但在大部分場景下，這個差距是微不足道的。文章來源地址http://www.zghlxwxcb.cn/news/detail-418628.html

到了這里，關(guān)于Lambda表達式：簡介、語法和用法的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！