寫在前面

在這篇文章中，我們將深入探討Java 8引入的Optional類，并展示它在實際應(yīng)用中的價值和好處。Optional類是一種用于處理可能為空的值的容器類型。通過使用Optional類，我們可以更加優(yōu)雅地處理可能存在空值的情況，避免了繁瑣的空值檢查和異常處理。通過閱讀本文，您將學(xué)會如何正確地處理可能為空的值，避免空指針異常，并提高代碼的可靠性和可維護性。無論您是Java初學(xué)者還是有經(jīng)驗的開發(fā)者，都能從中獲得實用的知識和技巧。

Java 8中的Optional類是一個容器類，用于解決null值引發(fā)的問題，并提供了一種更安全的方式來處理值可能為null的情況。

Optional類的主要目的是為了解決空指針異常（NullPointerException）的問題。在Java中，使用null值是一種常見的做法，但是這可能會導(dǎo)致運行時異常，特別是在進行對象引用的操作時。Optional類提供了一種方式來更明確地處理可能為null的值，從而避免出現(xiàn)NullPointerException。

Optional類提供了一些方法來檢查值是否存在以及獲取值。例如，isPresent()方法用于檢查值是否存在，get()方法用于獲取值，orElse()方法用于提供一個默認值，orElseGet()方法用于提供一個生成值的表達式，orElseThrow()方法用于提供一個異常。

使用Optional類可以使得代碼更加簡潔、安全和易于理解。通過使用Optional類，開發(fā)者可以明確地表明值可能為null，并且可以提供適當(dāng)?shù)奶幚矸绞?。這有助于減少運行時異常，提高代碼的可靠性和可維護性。

作為java8新增特性中一個非常重要的內(nèi)容，Optional類當(dāng)然不同凡響，其特點必須是鮮明的，且往下看：

1. 類型安全的容器類：Optional類是一個容器類，可以保存類型化的值。它提供了類型安全的解決方案，以避免使用null值。
2. 減少NullPointerException：使用Optional類可以避免在代碼中出現(xiàn)NullPointerException。它提供了一種明確的方式來處理可能為null的值，從而避免了運行時異常。
3. 鏈?zhǔn)秸{(diào)用：Optional類支持鏈?zhǔn)秸{(diào)用，可以在一行代碼中執(zhí)行多個操作。這種簡潔的語法使得代碼更加易讀和易于理解。
4. 可選的方法鏈：Optional類提供了一系列可選的方法，例如isPresent()、get()、orElse()、orElseGet()、orElseThrow()等。這些方法可以根據(jù)需要選擇使用，以滿足不同的場景需求。
5. 函數(shù)式編程風(fēng)格：Optional類是Java 8引入函數(shù)式編程風(fēng)格的體現(xiàn)之一。它提供了流式編程的支持，可以與其他函數(shù)式編程風(fēng)格的方法（如Stream）一起使用，實現(xiàn)更靈活和高效的代碼編寫。

總之，Java 8的Optional類是一個非常有用的工具，它提供了更安全、更靈活和更簡潔的方式來處理可能為null的值。

Optional的核心方法

掌握其核心方法的使用，其實也沒有什么竅門，就是逐一擊破。下面將逐一給小伙伴一一展示每一個方法的功能作用和使用方法，建議先行關(guān)注和收藏，以便后續(xù)想用時隨時可以找到。

Optional#empty()

Optional.empty()是Optional類的一個靜態(tài)方法，用于返回一個空的Optional對象。這個方法的主要功能作用是提供一個默認的Optional對象，當(dāng)需要使用Optional但實際沒有值可供包裝時，就可以使用Optional.empty()來代替。

使用場景：

1. 當(dāng)你期望返回一個Optional對象，但實際上沒有值可以返回時，可以使用Optional.empty()
2. 在使用Optional對象進行鏈?zhǔn)秸{(diào)用時，如果某個鏈?zhǔn)秸{(diào)用的結(jié)果為null，可以使用Optional.empty()

使用示例：

@Test
public void test() {
    List list=new ArrayList();
    Optional<String> optional = Optional.of(list).empty();
    if (!optional.isPresent()) {
        System.out.println("Optional is empty");
    } else {
        System.out.println("Optional is not empty, value = " + optional.get());
    }
}

在這個示例中，我們創(chuàng)建了一個空的Optional對象，并使用isPresent()方法檢查它是否包含一個值。由于Optional是空的，所以isPresent()方法返回false，打印出"Optional is empty"。如果我們試圖使用get()方法獲取值，會拋出NoSuchElementException異常。

Optional#of()和Optional#ofNullable()

Optional#of()和 Optional.ofNullable()是 Java 8 中 Optional 類的一個靜態(tài)工廠方法，它的功能作用是創(chuàng)建一個包含指定值的 Optional 對象。如果該值不為 null，則返回一個包含該值的 Optional 對象；如果該值為 null，則這里需要特別注意一下：Optional.of()要求接收的參數(shù)必須不能為null，否則會拋出空指針異常；而Optional.ofNullable()可以接受一個為null的參數(shù)；

使用場景：

• 當(dāng)需要使用一個可能為 null 的值時，可以使用 Optional#ofNullable() ；
• 在需要返回一個 Optional 對象作為函數(shù)或方法的結(jié)果時，可以使用 Optional#of() 或ofNullable；
• 在需要使用 Optional 對象進行鏈?zhǔn)秸{(diào)用時，可以使用 Optional#of() 或ofNullable；

使用示例：

@Test
public void test2() {
    String value = "Hello, world!";
    Optional<String> optional = Optional.of(value);
    // 如果 value 不為 null，則 optional 包含 value 的值
    System.out.println(optional.get());  // 輸出 "Hello, world!"
    // 如果 value 為 null，則 optional 為空
    Optional<String> emptyOptional = Optional.ofNullable(null);
    System.out.println(emptyOptional.isPresent());  // 輸出 "false"
}

在上面的示例中，我們使用 Optional#of() 方法創(chuàng)建了一個包含字符串值的 Optional 對象。如果該值不為 null，則可以通過調(diào)用 get() 方法來獲取該值；如果該值為 null，則使用Optional.ofNullable()返回一個空的 Optional 對象。

Optional#get()

Optional#get()是Java 8中Optional類的一個主要方法，用于獲取Optional對象中封裝的數(shù)據(jù)值。它的功能作用是當(dāng)Optional對象中存在有效值時，返回該值；否則，拋出一個NoSuchElementException異常。

使用場景：

1. 當(dāng)你期望Optional對象中一定存在有效值時，可以使用get()方法直接獲取該值。
2. 當(dāng)你需要從Optional對象中獲取一個默認值時，可以使用getOrDefault()方法，它會在Optional對象中不存在有效值時返回一個默認值。
3. 在進行鏈?zhǔn)秸{(diào)用時，可以使用get()方法來獲取上一個Optional對象的結(jié)果。

使用示例：

@Test
public void test3() {
    Optional<String> optional = Optional.of("Hello");
    String value = optional.get(); // 獲取Optional對象中的值
    System.out.println(value); // 輸出: Hello
}
如果Optional對象中不存在有效值，使用get()方法會拋出NoSuchElementException異常：
@Test
public void test4() {
    Optional<String> optional = Optional.empty();
    String value = optional.get(); // 拋出 NoSuchElementException 異常
}

為了避免異常的發(fā)生，可以使用isPresent()方法先檢查Optional對象中是否存在有效值：

@Test
public void test5() {
    Optional<String> optional = Optional.empty();
    if (optional.isPresent()) {
        String value = optional.get(); // 獲取值或拋出異常
        System.out.println(value);
    } else {
        System.out.println("Value not present");
    }
}

Optional#isPresent()

Optional.isPresent()是Java 8中Optional類的一個方法。它的功能作用是檢查Optional對象中是否有值，如果有值則返回true，否則返回false。

使用場景：

1. 當(dāng)你需要檢查一個值是否存在時，可以使用Optional.isPresent()
2. 在函數(shù)式編程中，Optional.isPresent()

使用示例：

@Test
public void test6() {
    Optional<String> optional = Optional.ofNullable(null);
    if (optional.isPresent()) {
        System.out.println("Value is present!");
    } else {
        System.out.println("Value is not present.");
    }
}

在這個示例中，我們首先通過Optional.ofNullable()方法創(chuàng)建了一個Optional對象。然后，我們使用isPresent()方法檢查值是否存在。如果值存在，我們就打印"Value is present!"，否則打印"Value is not present."。

Optional#isEmpty()

Optional#isEmpty()是Java 8中Optional類的一個方法，用于檢查Optional對象是否為空。如果Optional對象中沒有包含任何值，即值是null，那么isEmpty()方法將返回true，否則返回false。

功能作用：

1. 檢查Optional對象是否為空：使用isEmpty()方法可以判斷Optional對象是否不包含任何值，即值是否為null。
2. 提供安全訪問：通過檢查Optional對象是否為空，可以避免在嘗試訪問空值時出現(xiàn)NullPointerException。

使用場景：

1. 參數(shù)校驗：在方法中接收一個Optional參數(shù)時，可以使用isEmpty()方法進行參數(shù)校驗，確保參數(shù)非空。
2. 鏈?zhǔn)秸{(diào)用：在鏈?zhǔn)秸{(diào)用中，可以使用isEmpty()方法判斷鏈?zhǔn)秸{(diào)用是否已經(jīng)結(jié)束，或者下一個可用的元素是否存在。
3. 異常處理：在處理可能為null的值時，可以使用isEmpty()方法進行異常處理，以避免出現(xiàn)NullPointerException。

使用示例：

@Test
public void test7(){
    Optional<String> optional = Optional.of(new ArrayList<>()).empty();
    if (optional.isEmpty()) {
        System.out.println("Optional對象為空");
    } else {
        System.out.println("Optional對象不為空，值為：" + optional.get());
    }
}

在上面的示例中，我們創(chuàng)建了一個空的Optional對象optional，然后使用isEmpty()方法檢查其是否為空。由于optional是一個空的Optional對象，因此isEmpty()方法返回true，輸出"Optional對象為空"。

Optional#ifPresent()

Optional#ifPresent()是Java 8中Optional類的一個方法，用于在Optional對象非空時執(zhí)行指定的操作。

功能作用：

1. 條件判斷：ifPresent()方法判斷Optional對象是否非空，如果非空則執(zhí)行指定的操作。
2. 避免NullPointerException：通過ifPresent()方法可以避免在Optional對象為空時執(zhí)行操作而導(dǎo)致的NullPointerException。
3. 代碼簡潔性：使用ifPresent()方法可以使代碼更加簡潔和易讀，避免過多的if語句。

使用場景：

1. 條件判斷：在需要判斷Optional對象是否非空并執(zhí)行操作的情況下，可以使用ifPresent()方法。例如，在需要讀取文件時，可以使用Optional#ifPresent()方法判斷文件是否存在并讀取文件內(nèi)容。
2. 鏈?zhǔn)秸{(diào)用：在鏈?zhǔn)秸{(diào)用中，可以使用ifPresent()方法判斷鏈?zhǔn)秸{(diào)用是否已經(jīng)結(jié)束，或者下一個可用的元素是否存在。
3. 異常處理：在處理可能為null的值時，可以使用ifPresent()方法進行異常處理，以避免出現(xiàn)NullPointerException。

使用示例：

@Test
public void test8(){
    Optional<String> optional = Optional.ofNullable(null);
    optional.ifPresent(s -> System.out.println("值不為空，值為：" + s));
    Optional<String> optional2 = Optional.ofNullable("hello");
    optional2.ifPresent(s -> System.out.println("值不為空，值為：" + s));
}

在上面的示例中，我們首先使用getNullableString()方法返回一個可能為null的String對象，然后將其封裝為一個Optional對象optional。接著，我們使用ifPresent()方法判斷optional是否非空，如果非空則打印出字符串的值。

Optional#ifPresentOrElse()

Optional#ifPresentOrElse()是Java 8中Optional類的一個方法，用于在Optional對象非空時執(zhí)行指定的操作，否則執(zhí)行另一個指定的操作。它允許在Optional對象存在時進行條件判斷和執(zhí)行相應(yīng)的操作。

功能作用：

1. 條件判斷：ifPresentOrElse()方法接受兩個參數(shù)，第一個參數(shù)是一個Lambda表達式，用于判斷Optional對象是否非空；第二個參數(shù)也是一個Lambda表達式，用于在Optional對象非空時執(zhí)行相應(yīng)的操作。
2. 避免NullPointerException：通過使用ifPresentOrElse()方法，可以在Optional對象非空時執(zhí)行相應(yīng)的操作，避免了直接訪問空值時可能出現(xiàn)的NullPointerException異常。

使用場景：

1. 條件處理：當(dāng)需要基于Optional對象是否存在進行條件處理時，可以使用ifPresentOrElse()方法。例如，根據(jù)Optional對象是否非空來決定執(zhí)行哪些操作或者返回默認值。
2. 鏈?zhǔn)秸{(diào)用：在鏈?zhǔn)秸{(diào)用中，可以使用ifPresentOrElse()方法進行條件判斷和執(zhí)行相應(yīng)的操作，以實現(xiàn)更簡潔的代碼。

使用示例：

@Test
public void test9() {
    Optional<String> optional = Optional.ofNullable(null);
    optional.ifPresentOrElse(
            value -> System.out.println("Optional對象非空，值為：" + value),
            () -> System.out.println("Optional對象為空")
    );
    Optional<String> optional2 = Optional.ofNullable("hello");
    optional2.ifPresentOrElse(
            value -> System.out.println("Optional對象非空，值為：" + value),
            () -> System.out.println("Optional對象為空")
    );
}

在上面的示例中，我們首先獲取一個可能為null的字符串，然后將其封裝在一個Optional對象中。接下來，我們使用ifPresentOrElse()方法進行條件判斷。如果Optional對象非空，就輸出該值；否則，輸出"Optional對象為空"。由于該示例中的Optional對象是非空的，因此會輸出"Optional對象非空，值為："加上該字符串的值。

Optional#filter()

Optional#filter()是Java 8中Optional類的一個方法，用于過濾Optional對象中的值。它接受一個Predicate接口作為參數(shù)，該接口用于定義一個判斷條件。當(dāng)Optional對象非空并且滿足給定的條件時，filter()方法將返回一個包含該值的Optional對象；否則，返回一個空的Optional對象。

功能作用：

1. 過濾值：使用filter()方法可以過濾Optional對象中的值，只保留滿足特定條件的值。
2. 提高代碼的可讀性：通過使用lambda表達式和filter()方法，可以將復(fù)雜的條件邏輯集中在一個地方，使代碼更加簡潔和易于理解。

使用場景：

1. 條件判斷：當(dāng)需要對Optional對象中的值進行條件判斷時，可以使用filter()方法來過濾出符合條件的值。
2. 流式編程：在流式編程中，可以使用filter()方法來對元素進行篩選，以實現(xiàn)更靈活和高效的數(shù)據(jù)處理。

使用示例：

@Test
public void test10(){
    Optional<String> optional = Optional.of("Hello");
    Optional<String> filteredOptional = optional.filter(s -> s.startsWith("H"));
    if (filteredOptional.isPresent()) {
        System.out.println(filteredOptional.get()); // 輸出 "Hello"
    } else {
        System.out.println("Optional對象為空或條件不滿足");
    }
}

在上面的示例中，我們創(chuàng)建了一個包含字符串"Hello"的Optional對象optional，然后使用filter()方法來過濾出以"H"開頭的字符串。由于optional中的值滿足以"H"開頭的條件，因此filter()方法返回一個包含該值的Optional對象。最后，我們使用isPresent()方法檢查Optional對象是否非空，并使用get()方法獲取值。

Optional#map()

Optional#map()是Java 8中Optional類的一個方法，用于將Optional對象中的值轉(zhuǎn)換為一個新的值。它接受一個函數(shù)作為參數(shù)，該函數(shù)用于將Optional對象中的值轉(zhuǎn)換為一個新的值。如果Optional對象為空，map()方法不會執(zhí)行轉(zhuǎn)換操作。

功能作用：

1. 轉(zhuǎn)換Optional對象中的值：通過傳遞一個函數(shù)作為參數(shù)，map()方法可以將Optional對象中的值轉(zhuǎn)換為一個新的值。
2. 提供安全訪問：在Optional對象為空的情況下，map()方法不會嘗試執(zhí)行轉(zhuǎn)換操作，從而避免出現(xiàn)NullPointerException。

使用場景：

1. 類型轉(zhuǎn)換：可以使用map()方法將Optional對象中的值轉(zhuǎn)換為一個新的類型，例如將String類型的值轉(zhuǎn)換為Integer類型。
2. 條件操作：可以使用map()方法根據(jù)Optional對象中的值執(zhí)行條件操作，例如根據(jù)一個字符串的長度是否大于某個閾值來決定是否執(zhí)行某個操作。
3. 鏈?zhǔn)秸{(diào)用：在鏈?zhǔn)秸{(diào)用中，可以使用map()方法將Optional對象中的值轉(zhuǎn)換為一個新的值，并將其傳遞給下一個操作。

使用示例：

@Test
public void test11(){
    Optional<String> optional = Optional.of("Hello");
    Optional<Integer> result = optional.map(str -> str.length());
    if (result.isPresent()) {
        System.out.println("Length of string: " + result.get());
    } else {
        System.out.println("Optional對象為空");
    }
    Optional<String> optional2 = Optional.ofNullable(null);
    Optional<Integer> result2 = optional.map(str -> str.length());
    if (result2.isPresent()) {
        System.out.println("Length of string: " + result2.get());
    } else {
        System.out.println("Optional對象為空");
    }
}

在上面的示例中，我們創(chuàng)建了一個包含字符串"Hello"的Optional對象optional，然后使用map()方法將其轉(zhuǎn)換為一個包含字符串長度的Optional對象result。由于optional不為空，map()方法執(zhí)行了轉(zhuǎn)換操作，將字符串"Hello"的長度作為新值存儲在result中。最后，我們檢查result是否為空，如果不為空則輸出字符串的長度。

Optional#flatMap()

Optional#flatMap()是Java 8中Optional類的一個方法，用于將Optional對象中的值映射為另一個Optional對象，

功能作用：

1. 映射Optional對象：使用flatMap()方法可以將一個Optional對象中的值映射為另一個Optional對象。這個方法接受一個函數(shù)作為參數(shù)，這個函數(shù)用于處理Optional對象中的值。

使用場景：

1. 鏈?zhǔn)秸{(diào)用：在鏈?zhǔn)秸{(diào)用中，可以使用flatMap()方法將一個Optional對象轉(zhuǎn)換為一個Stream，然后再對Stream進行處理。這種做法可以使代碼更加簡潔和易讀。
2. 處理復(fù)雜數(shù)據(jù)結(jié)構(gòu)：當(dāng)需要處理復(fù)雜的數(shù)據(jù)結(jié)構(gòu)時，可以使用flatMap()方法將嵌套的Optional對象轉(zhuǎn)換為簡單的Stream，以便于進一步處理。

使用示例：

在下面的示例中，我們首先創(chuàng)建了一個String類型的name，并將其封裝在一個Optional對象中。然后，我們使用flatMap()方法將這個Optional對象轉(zhuǎn)換為另一個Optional對象，辦的的邏輯是把原先的小寫字符轉(zhuǎn)換為大寫字符，最后使用optional.get()取出轉(zhuǎn)換結(jié)果并輸出。

@Test
public void test12() {
    String name = "fanfu1024";
    Optional<String> optional = Optional.of(name).flatMap(item -> Optional.of(item.toUpperCase()));
    String name2 = optional.get();
    System.out.println(name2);//輸出結(jié)果：FANFU1024
}

Optional#or()

Optional#or()是Java 8中Optional類的一個方法，用于在Optional對象為空時提供一個默認值，或者在Optional對象為空時執(zhí)行一個備用操作。這個方法在處理可能為null的值時非常有用，可以避免出現(xiàn)NullPointerException。

功能作用：

1. 提供默認值：當(dāng)Optional對象為空時，or()方法可以提供一個默認值。這個默認值可以是任何類型，包括對象、基本類型、集合等。
2. 執(zhí)行備用操作：當(dāng)Optional對象為空時，or()方法還可以執(zhí)行一個備用操作。這個操作可以是任何代碼塊，包括函數(shù)、方法調(diào)用等。

使用場景：

1. 默認值處理：在需要使用可能為null的值時，可以使用or()方法提供一個默認值，以避免出現(xiàn)NullPointerException。
2. 備用操作處理：當(dāng)需要在Optional對象為空時執(zhí)行某些操作時，可以使用or()方法執(zhí)行這些備用操作。

使用示例：

@Test
public void test13(){
    Optional<String> optional = Optional.empty();
    String value = optional.or(() -> Optional.of("default value")).get();// 提供默認值
    System.out.println(value); // 輸出"default value"


    Optional<String> optional2 = Optional.of("Hello");
    String value2 = optional2.or(() -> Optional.of("default value")).get(); // 執(zhí)行備用操作
    System.out.println(value2); // 輸出"Hello"
}

在上面的示例中，我們首先創(chuàng)建了一個空的Optional對象optional，然后使用or()方法提供一個默認值"default value"，當(dāng)optional為空時將返回這個默認值。然后我們創(chuàng)建了一個包含字符串"Hello"的Optional對象optional2，使用or()方法執(zhí)行一個備用操作，當(dāng)optional2為空時返回"default value"，但是由于optional2包含值"Hello"，因此返回"Hello"。這個示例展示了or()方法在處理Optional對象時的使用。

Optional#stream()

Optional#stream()是Java 8中Optional類的一個方法，用于將Optional對象轉(zhuǎn)換為一個Stream。這個方法在需要使用流式編程處理數(shù)據(jù)時非常有用。

功能作用：

1. 轉(zhuǎn)換類型：將Optional對象轉(zhuǎn)換為Stream類型，以便進行流式編程。
2. 空值處理：當(dāng)Optional對象為空時，stream()方法返回一個空的Stream。

使用場景：

1. 流式編程：使用stream()方法可以將Optional對象轉(zhuǎn)換為Stream，然后與其他流式編程的方法一起使用，實現(xiàn)更靈活和高效的數(shù)據(jù)處理。
2. 鏈?zhǔn)秸{(diào)用：在鏈?zhǔn)秸{(diào)用中，可以使用stream()方法將每個Optional對象轉(zhuǎn)換為一個Stream，然后進行進一步的處理。
3. 復(fù)雜數(shù)據(jù)結(jié)構(gòu)處理：當(dāng)處理復(fù)雜數(shù)據(jù)結(jié)構(gòu)時，可以使用stream()方法將嵌套的Optional對象展開，以便更好地處理數(shù)據(jù)。

使用示例：

@Test
public void test14(){
    Optional<String> optional = Optional.of("Hello");
    Stream<String> stream = optional.stream(); // 將Optional對象轉(zhuǎn)換為Stream
    List<String> result = stream.collect(Collectors.toList()); // 將Stream轉(zhuǎn)換為List
    System.out.println(result); // 輸出["Hello"]
}

在上面的示例中，我們創(chuàng)建了一個包含字符串"Hello"的Optional對象optional，然后使用stream()方法將其轉(zhuǎn)換為Stream對象stream。接著，我們將stream轉(zhuǎn)換為List對象result。這個示例展示了stream()方法在將Optional對象轉(zhuǎn)換為Stream時的使用。

Optional#orElse()

Optional#orElse()是Java 8中Optional類的一個方法，用于在Optional對象為空時返回一個默認值，或者在Optional對象為空時執(zhí)行一個備用操作。這個方法在處理可能為null的值時非常有用，可以避免出現(xiàn)NullPointerException。

功能作用：

1. 返回默認值：當(dāng)Optional對象為空時，orElse()方法可以提供一個默認值。這個默認值可以是任何類型，包括對象、基本類型、集合等。
2. 執(zhí)行備用操作：當(dāng)Optional對象為空時，orElse()方法還可以執(zhí)行一個備用操作。這個操作可以是任何代碼塊，包括函數(shù)、方法調(diào)用等。

使用場景：

1. 默認值處理：在需要使用可能為null的值時，可以使用orElse()方法提供一個默認值，以避免出現(xiàn)NullPointerException。
2. 備用操作處理：當(dāng)需要在Optional對象為空時執(zhí)行某些操作時，可以使用orElse()方法執(zhí)行這些備用操作。

使用示例：

@Test
public void test15() {
    Optional<String> optional = Optional.empty();
    String value = optional.orElse("default value"); // 返回默認值
    System.out.println(value); // 輸出"default value"


    Optional<String> optional2 = Optional.of("Hello");
    String value2 = optional2.orElse("default value"); // 執(zhí)行備用操作
    System.out.println(value2); // 輸出"Hello"
}

在上面的示例中，我們首先創(chuàng)建了一個空的Optional對象optional，然后使用orElse()方法提供一個默認值"default value"，當(dāng)optional為空時將返回這個默認值。然后我們創(chuàng)建了一個包含字符串"Hello"的Optional對象optional2，使用orElse()方法執(zhí)行一個備用操作，當(dāng)optional2為空時返回"default value"，但是由于optional2包含值"Hello"，因此返回"Hello"。這個示例展示了orElse()方法在處理Optional對象時的使用。

Optional#orElseGet()

Optional#orElseGet()是Java 8中Optional類的一個方法，用于在Optional對象為空時返回一個默認值，或者在Optional對象為空時執(zhí)行一個備用生成器。這個方法在處理可能為null的值時非常有用，可以避免出現(xiàn)NullPointerException。

功能作用：

1. 提供默認值：當(dāng)Optional對象為空時，orElseGet()方法可以返回一個默認值。這個默認值是由一個Supplier接口的實現(xiàn)提供的，可以是一個對象、基本類型、集合等。
2. 執(zhí)行備用生成器：當(dāng)Optional對象為空時，orElseGet()方法還可以執(zhí)行一個備用生成器。這個生成器是一個Supplier接口的實現(xiàn)，可以生成一個值作為默認值。

使用場景：

1. 默認值處理：在需要使用可能為null的值時，可以使用orElseGet()方法返回一個默認值，以避免出現(xiàn)NullPointerException。
2. 備用生成器處理：當(dāng)需要在Optional對象為空時執(zhí)行某些操作并生成一個值作為默認值時，可以使用orElseGet()方法執(zhí)行這些備用生成器。

使用示例：

@Test
public void test16() {
    Optional<String> optional = Optional.empty();
    String value = optional.orElseGet(() -> "default value"); // 返回默認值
    System.out.println(value); // 輸出"default value"


    Optional<String> optional2 = Optional.of("Hello");
    String value2 = optional2.orElseGet(() -> "default value"); // 執(zhí)行備用生成器
    System.out.println(value2); // 輸出"Hello"
}

在上面的示例中，我們首先創(chuàng)建了一個空的Optional對象optional，然后使用orElseGet()方法返回一個默認值"default value"，當(dāng)optional為空時將返回這個默認值。然后我們創(chuàng)建了一個包含字符串"Hello"的Optional對象optional2，使用orElseGet()方法執(zhí)行一個備用生成器，當(dāng)optional2為空時返回"default value"，但是由于optional2包含值"Hello"，因此返回"Hello"。這個示例展示了orElseGet()方法在處理Optional對象時的使用。

Optional#orElseThrow()

Optional#orElseThrow()是Java 8中Optional類的一個方法，用于在Optional對象為空時拋出一個異常。這個方法在需要確保一個值存在的情況下非常有用，如果該值不存在，則可以通過orElseThrow()方法拋出一個定制的異常。

功能作用：

1. 拋出異常：當(dāng)Optional對象為空時，orElseThrow()方法將拋出一個異常。可以提供自定義的異常信息或異常類型。
2. 強制要求值存在：通過orElseThrow()方法，可以強制要求Optional對象中存在一個值，否則將拋出異常。

使用場景：

1. 參數(shù)校驗：在方法中接收一個Optional參數(shù)時，可以使用orElseThrow()方法進行參數(shù)校驗，確保參數(shù)非空。
2. 流程控制：在某些情況下，需要在Optional對象為空時中斷當(dāng)前操作并拋出異常，以便進行特殊處理。
3. 異常處理：當(dāng)需要在Optional對象為空時拋出異常時，可以使用orElseThrow()方法實現(xiàn)這一需求。

使用示例：

@Test
public void test17() {
    Optional<String> optional = Optional.of("Hello");
    String value = optional.orElseThrow(() -> new NoSuchElementException("注意：空值?。?！"));
    System.out.println(value); // 正常情況，輸出"Hello"
    Optional<String> optional2 = Optional.empty();
    String value2 = optional2.orElseThrow(() -> new NoSuchElementException("注意：空值?。?！"));
    System.out.println(value); // 拋出異常
}

在上面的示例中，我們創(chuàng)建了一個空的Optional對象optional，然后使用orElseThrow()方法拋出一個NoSuchElementException異常。當(dāng)optional為空時，將拋出該異常并中斷程序的執(zhí)行。因此，在使用orElseThrow()方法時需要注意異常處理和流程控制，以確保程序的正確性和穩(wěn)定性。

總結(jié)

總之，Optional類提供了一些方法，可以更好地處理可能為null的情況，提供更多的選擇和個性化服務(wù)，使代碼更加簡潔、靈活和易讀。在使用Optional類時，需要根據(jù)具體的需求選擇合適的方法。