技術文章 » 告別空指標讓程式碼變優雅，Optional使用圖文例子原始碼解讀

告別空指標讓程式碼變優雅，Optional使用圖文例子原始碼解讀

2023-10-18 12:02:53

一、前言

我們在開發中最常見的異常就是NullPointerException，防不勝防啊，相信大家肯定被坑過！

這種基本出現在獲取資料庫資訊中、三方介面，獲取的物件為空，再去get出現！

解決方案當然簡單，只需要判斷一下，不是空在去後續操作，為空返回！

所有在JDK8時出現了專門處理的方案，出來很早了，但是小編慚愧一直沒有去使用它！

最近在看《Java開發手冊》，一直想著提高自己的程式碼水平，文中就指出了使用Optional來解決NullPointerException！

二、Java開發手冊規範

小編使用的是2022版的黃山版，29頁寫到：

【推薦】防止 NPE，是程式設計師的基本修養，注意 NPE 產生的場景：

  • 返回型別為基本資料型別，return 包裝資料型別的物件時，自動拆箱有可能產生 NPE

反例：public int method() { return Integer 物件; }，如果為 null，自動解箱拋 NPE。

  • 資料庫的查詢結果可能為 null。
  • 集合裡的元素即使 isNotEmpty，取出的資料元素也可能為 null。
  • 遠端呼叫返回物件時，一律要求進行空指標判斷，防止 NPE。
  • 對於 Session 中獲取的資料，建議進行 NPE 檢查，避免空指標。
  • 級聯呼叫 obj.getA().getB().getC()；一連串呼叫，易產生 NPE。

正例：使用 JDK8 的 Optional 類來防止 NPE 問題。

這份手冊還是不錯的，推薦反覆閱讀，雖然進不去大廠，也要自覺約束自己的程式碼風格，努力向大廠靠！

大家現在不知道哪裡找的可以下載一下：

《Java開發手冊》

三、Optional常用方法

小編帶大家一起從api檔案中的方法，一個個帶大家慢慢去了解它！

1. empty()

返回一個空的Optional範例：Optional.empty

Optional<Object> empty = Optional.empty();
log.info("empty值：{}",empty);

2. of(T value)

傳入一個引數，返回一個Optional物件，如果引數為空，報NullPointerException！

Test testNew  = new Test();
Test test = null;
Optional<Test> optionalNew = Optional.of(testNew);
log.info(" optional物件：{}",optionalNew);
Optional<Test> optional = Optional.of(test);

原始碼檢視：

我們看到引數為空會報NullPointerException，我們去方法內部看一下就明白了：

public static <T> Optional<T> of(T value) {
    return new Optional<>(value);
}
private Optional(T value) {
    this.value = Objects.requireNonNull(value);
}
public static <T> T requireNonNull(T obj) {
    if (obj == null)
        throw new NullPointerException();
    return obj;
}

我們發現是在Objects類中的requireNonNull方法中判斷了是否為空！

這個還會出現NullPointerException，所以我們一般使用下面的這個方法！

3. ofNullable(T value)

引數傳入一個物件，返回一個Optional物件，如果為空，將返回一個空的Optional物件，就等於Optional.empty

Test testNew  = new Test();
Test test = null;
Optional<Test> optionalNew = Optional.of(testNew);
log.info(" optional物件：{}",optionalNew);

Optional<Test> optionalTest = Optional.ofNullable(test);
log.info(" optional物件中的ofNullable方法返回值：{}",optionalTest);
Optional<Test> optionalTestNew = Optional.ofNullable(testNew);
log.info(" optional物件中的ofNullable方法new返回值：{}",optionalTestNew);

原始碼檢視：

我們發現是在方法開始進行非空判斷，再去呼叫上面的of(T value)方法

public static <T> Optional<T> ofNullable(T value) {
    return value == null ? empty() : of(value);
}

4. get()

如果此Optional中存在值，則返回該值，否則丟擲NoSuchElementException。

Test testNew  = new Test();
Test test = null;
Optional<Test> optionalNew = Optional.of(testNew);
log.info(" optional物件：{}",optionalNew);
// Optional<Test> optional = Optional.of(test);

Optional<Test> optionalTest = Optional.ofNullable(test);
log.info(" optional物件中的ofNullable方法返回值：{}",optionalTest);
Optional<Test> optionalTestNew = Optional.ofNullable(testNew);
log.info(" optional物件中的ofNullable方法new返回值：{}",optionalTestNew);

Test test2 = optionalTestNew.get();
log.info("原來有值的：經過Optional包裝後get後得到原來的值：{}",test2);
Test test1 = optionalTest.get();
log.info("原來沒有值的：經過Optional包裝後get後得到原來的值：{}",test1);

原始碼檢視：

呼叫開始會進行值判斷，如果為空則拋異常！

public T get() {
    if (value == null) {
        throw new NoSuchElementException("No value present");
    }
    return value;
}

5. isPresent()

如果存在值，則返回true，否則返回false。

這裡程式碼就不加上面的，大家參考上面的獲取一個Optional物件

boolean present = optionalTestNew.isPresent();
log.info("optionalTestNew呼叫是否為空：{}",present);
boolean present1 = optionalTest.isPresent();
log.info("optionalTest呼叫是否為空：{}",present1);

原始碼檢視：

這就比較簡單了!

public boolean isPresent() {
   return value != null;
}

6. ifPresent(Consumer<? super T> consumer)

如果存在值，則使用該值呼叫指定的使用者，否則不執行任何操作。

主要的就是入引數一個函數式介面，有值就會去執行，為空則不進行任何操作！

小技巧：

開始對lambda不瞭解時，可以先按照上面這種方式進行寫，

大家可以看到Idea給置灰了，就是可以優化，我們Alt+Enter
然後再次Enter就會變成後面的lambda！

optionalTest.ifPresent(new Consumer<Test>() {
    @Override
    public void accept(Test test) {
        log.info("我是呼叫ifPresent執行後的列印=====");
    }
});
optionalTestNew.ifPresent(testInner -> log.info("我是呼叫ifPresent執行後的列印"));

原始碼檢視：

還是先判斷不為空才去執行函數式介面！

public void ifPresent(Consumer<? super T> consumer) {
    if (value != null)
        consumer.accept(value);
}

7. filter(Predicate<? super T> predicate)

如果存在值，並且該值符合規則，則返回描述該值的Optional，否則返回空Optional

是一個Predicate函數介面，可以傳入實現了Predicate介面的lambda表示式！
如果不符合條件就會返回一個Optional.empty

testNew.setName("蕭炎");
testNew.setAge(33);
Optional<Test> optionalTest1 = optionalTestNew.filter(test1 -> test1.getAge() > 30);
log.info("過濾後的結果：{}",optionalTest1.get());

原始碼檢視：

就是判斷一下表示式和值是否為空，然後就是根據規則判斷

public Optional<T> filter(Predicate<? super T> predicate) {
   Objects.requireNonNull(predicate);
    if (!isPresent())
        return this;
    else
        return predicate.test(value) ? this : empty();
}

8. map(Function<? super T,? extends U> mapper)

如果存在值，則將提供的對映函數應用於該值，如果結果為非空，則返回描述結果的Optional。否則，返回空的Optional。

也是一個函數式介面！

Optional<String> stringOptional = optionalTestNew.map(Test::getName);
log.info("map後獲得欄位值：{}",stringOptional.get());

原始碼檢視：

也是進行非空判斷，然後執行lambda得到欄位後放到ofNullable方法中！

public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent())
        return empty();
    else {
        return Optional.ofNullable(mapper.apply(value));
    }
}

9. flatMap(Function<? super T,Optional<U>> mapper)

如果存在值，則將提供的Optional方位對映函數應用於該值，返回該結果，否則返回空的Optional。此方法類似於map，但提供的對映器的結果已經是可選的，並且如果呼叫，flatMap不會不會在最後進行任何包裝。

Optional<String> optional = optionalTestNew.flatMap(OptionalTest::getFlatMap);
log.info("flatMap後得到的欄位：{}",optional.get());

private static Optional<String> getFlatMap(Test test){
    return Optional.ofNullable(test).map(Test::getName);
}


原始碼檢視：

也是進行非空判斷，然後和map不同的是不執行ofNullable方法

public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent())
        return empty();
    else {
        return Objects.requireNonNull(mapper.apply(value));
    }
}

10. orElse(T other)

如果有值則將其返回，否則返回指定的其它值。

如果你是一個物件，orElse()也要是相同物件！

String message = null;
String messageNew = "關注公眾號：小王部落格基地";

String nullString = Optional.ofNullable(message).orElse("這是一個空字串！");
log.info("這是空字串列印的：{}",nullString);
String string = Optional.ofNullable(messageNew).orElse("=====這是一個空字串！");
log.info("這是字串列印的：{}",string);

原始碼檢視：

簡單的為空返回自己定義的，不為空直接返回！

public T orElse(T other) {
    return value != null ? value : other;
}

11. orElseGet(Supplier<? extends T> other)

返回值（如果存在），否則呼叫other並返回該呼叫的結果。

區別：
orElse方法將傳入的引數作為預設值，orElseGet方法可以接受Supplier介面的實現用來生成預設值

如果沒有複雜操作，Idea也會提醒我們不要使用這個，使用orElse即可！

String message = null;
String messageNew = "關注公眾號：小王部落格基地";
String orElseGet = Optional.ofNullable(message).orElseGet(() -> "這還是一個空的字串");
log.info("orElseGet呼叫：這是空字串列印的：{}",orElseGet);
String orElseGetString = Optional.ofNullable(messageNew).orElseGet(() -> "這還是一個空的字串");
log.info("orElseGet呼叫：這是字串列印的：{}",orElseGetString);

原始碼檢視：

和orElse一樣，只不過為空呼叫lambda執行！

public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}

12. orElseThrow(Supplier<? extends X> exceptionSupplier)

返回包含的值（如果存在），否則丟擲由提供的供應商建立的異常。

String message = null;
String messageNew = "關注公眾號：小王部落格基地";
Optional.ofNullable(messageNew).orElseThrow(() -> new RuntimeException("為空了，還不看看！"));
Optional.ofNullable(message).orElseThrow(() -> new RuntimeException("為空了，還不看看！"));

我們可以自定義異常，然後來參照！

原始碼檢視：

為空則走自己寫的異常！

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    if (value != null) {
        return value;
    } else {
        throw exceptionSupplier.get();
    }
}

13. 例子彙總

/**
 * @author wangzhenjun
 * @date 2023/2/27 10:22
 */
@Slf4j
public class OptionalTest {

    public static void main(String[] args) {

        Optional<Object> empty = Optional.empty();
        log.info("empty值：{}",empty);


        Test testNew  = new Test();
        Test test = null;
        Optional<Test> optionalNew = Optional.of(testNew);
        log.info(" optional物件：{}",optionalNew);
//        Optional<Test> optional = Optional.of(test);

        Optional<Test> optionalTest = Optional.ofNullable(test);
        log.info(" optional物件中的ofNullable方法返回值：{}",optionalTest);
        Optional<Test> optionalTestNew = Optional.ofNullable(testNew);
        log.info(" optional物件中的ofNullable方法new返回值：{}",optionalTestNew);

        Test test2 = optionalTestNew.get();
        log.info("原來有值的：經過Optional包裝後get後得到原來的值：{}",test2);
        // Test test1 = optionalTest.get();
        // log.info("原來沒有值的：經過Optional包裝後get後得到原來的值：{}",test1);

        boolean present = optionalTestNew.isPresent();
        log.info("optionalTestNew呼叫是否為空：{}",present);
        boolean present1 = optionalTest.isPresent();
        log.info("optionalTest呼叫是否為空：{}",present1);

        optionalTest.ifPresent(new Consumer<Test>() {
            @Override
            public void accept(Test test) {
                log.info("我是呼叫ifPresent執行後的列印=====");
            }
        });
        optionalTestNew.ifPresent(testInner -> log.info("我是呼叫ifPresent執行後的列印"));

        testNew.setName("蕭炎");
        testNew.setAge(33);
        Optional<Test> optionalTest1 = optionalTestNew.filter(test1 -> test1.getAge() > 30);
        log.info("過濾後的結果：{}",optionalTest1.get());

        Optional<String> stringOptional = optionalTestNew.map(Test::getName);
        log.info("map後獲得欄位值：{}",stringOptional.get());

        Optional<String> optional = optionalTestNew.flatMap(OptionalTest::getFlatMap);
        log.info("flatMap後得到的欄位：{}",optional.get());

        String message = null;
        String messageNew = "關注公眾號：小王部落格基地";

        String nullString = Optional.ofNullable(message).orElse("這是一個空字串！");
        log.info("這是空字串列印的：{}",nullString);
        String string = Optional.ofNullable(messageNew).orElse("=====這是一個空字串！");
        log.info("這是字串列印的：{}",string);

        String orElseGet = Optional.ofNullable(message).orElseGet(() -> "這還是一個空的字串");
        log.info("orElseGet呼叫：這是空字串列印的：{}",orElseGet);
        String orElseGetString = Optional.ofNullable(messageNew).orElseGet(() -> "這還是一個空的字串");
        log.info("orElseGet呼叫：這是字串列印的：{}",orElseGetString);

        Optional.ofNullable(messageNew).orElseThrow(() -> new RuntimeException("為空了，還不看看！"));
        Optional.ofNullable(message).orElseThrow(() -> new RuntimeException("為空了，還不看看！"));



    }

    private static Optional<String> getFlatMap(Test test){
        return Optional.ofNullable(test).map(Test::getName);
    }

}

四、總結

這裡就不在演示實戰了，基本上組合使用：

Optional.ofNullable(需要判斷的物件).ifPresent(具體操作)

其實和if相比就是顯得優雅一些，主要是防止某處沒考慮到，忘記if判斷，那麼後續可能會導致空指標，如果使用Optional的話，那麼這個問題能夠得到避免。

就像多使用設計模式一樣，讓自己的程式碼更加健壯優雅，還是要多使用一些的！當然不能過渡使用！！

對你有幫助，還請不要吝嗇你的發財小手點點關注哈！、
寫作不易，大家給點支援，你的支援是我寫作的動力哈！

關注小編的微信公眾號：『小王部落格基地』，一起交流學習！文章首發看哦！

建了一個IT交流群，歡迎大家加入，過期加我拉你們進哈！