Java8的Optional怎么使用

這篇文章主要講解了“Java8的Optional怎么使用”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Java8的Optional怎么使用”吧！

引言

寫過 Java 程序的同學，一般都遇到過 NullPointerException —— 為了不拋出這個異常，我們便會寫如下的代碼：

User user = getUserById(id);

if (user != null) {

   String username = user.getUsername();

   System.out.println("Username is: " + username); // 使用 username

}

但是很多時候，我們可能會忘記寫 if (user != null) —— 如果在開發階段就發現那還好，但是如果在開發階段沒有測試到問題，等到上線卻出了 NullPointerException ... 畫面太美，我不敢繼續想下去。

為了解決這種尷尬的處境，JDK 終于在 Java8 的時候加入了 Optional 類。Optional 的 javadoc 介紹：

A container object which may or may not contain a non-null value. If a value is present,
 isPresent() will return true and get() will return the value.

這是一個可以包含或者不包含非 null 值的容器。如果值存在則 isPresent()方法會返回 true，調用 get() 方法會返回該對象。

一、簡介

    Optional類是Java8為了解決null值判斷問題，借鑒google guava類庫的Optional類而引入的一個同名Optional類，使用Optional類可以避免顯式的null值判斷（null的防御性檢查），避免null導致的NPE（NullPointerException）。

    我們來看一段代碼：

    public static String getGender(Student student)
    {
        if(null == student)
        {
            return "Unkown";
        }
        return student.getGender();
        
    }

這是一個獲取學生性別的方法，方法入參為一個Student對象，為了防止student對象為null， 做了防御性檢查：如果值為null，返回"Unkown"。

    再看使用Optional優化后的方法：

    public static String getGender(Student student)
    {
       return Optional.ofNullable(student).map(u -> u.getGender()).orElse("Unkown");
        
    }

    可以看到，Optional類結合lambda表達式的使用能夠讓開發出的代碼更簡潔和優雅。

二、Optional對象的創建

     我們看下Optional類的部分源碼：

    private static final Optional<?> EMPTY = new Optional<>();

    private final T value;

    private Optional() {
        this.value = null;
    }

    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

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

可以看出，Optional類的兩個構造方法都是private型的，因此類外部不能顯示的使用new Optional()的方式來創建Optional對象，但是Optional類提供了三個靜態方法empty()、of(T value)、ofNullable(T value)來創建Optinal對象，示例如下：

// 1、創建一個包裝對象值為空的Optional對象
Optional<String> optStr = Optional.empty();
// 2、創建包裝對象值非空的Optional對象
Optional<String> optStr1 = Optional.of("optional");
// 3、創建包裝對象值允許為空的Optional對象
Optional<String> optStr2 = Optional.ofNullable(null);

三、Optional 類典型接口的使用

下面以一些典型場景為例，列出Optional API常用接口的用法，并附上相應代碼。

前面 javadoc 也有提到，Optional 的 isPresent() 方法用來判斷是否包含值，get() 用來獲取 Optional 包含的值 —— 值得注意的是，如果值不存在，即在一個Optional.empty 上調用 get() 方法的話，將會拋出 NoSuchElementException 異常。

我們假設 getUserById 已經是個客觀存在的不能改變的方法，那么利用 isPresent 和 get 兩個方法，我們現在能寫出下面的代碼：

Optional<User> user = Optional.ofNullable(getUserById(id));

if (user.isPresent()) {

  String username = user.get().getUsername();

  System.out.println("Username is: " + username); // 使用 username

}

好像看著代碼是優美了點 —— 但是事實上這與之前判斷 null 值的代碼沒有本質的區別，反而用 Optional 去封裝 value，增加了代碼量。所以我們來看看 Optional 還提供了哪些方法，讓我們更好的（以正確的姿勢）使用 Optional。

3.1  get()方法

     簡單看下get()方法的源碼：

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

可以看到，get()方法主要用于返回包裝對象的實際值，但是如果包裝對象值為null，會拋出NoSuchElementException異常。

3.2  isPresent()方法

     isPresent()方法的源碼：

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

可以看到，isPresent()方法用于判斷包裝對象的值是否非空。下面我們來看一段糟糕的代碼：

    public static String getGender(Student student)
    {
        Optional<Student> stuOpt =  Optional.ofNullable(student);
        if(stuOpt.isPresent())
        {
            return stuOpt.get().getGender();
        }
        
        return "Unkown";
    }

這段代碼實現的是第一章(簡介)中的邏輯，但是這種用法不但沒有減少null的防御性檢查，而且增加了Optional包裝的過程，違背了Optional設計的初衷，因此開發中要避免這種糟糕的使用~

3.3  ifPresent()方法

     ifPresent()方法的源碼：

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

ifPresent()方法接受一個Consumer對象（消費函數），如果包裝對象的值非空，運行Consumer對象的accept()方法。示例如下：

    public static void printName(Student student)
    {
        Optional.ofNullable(student).ifPresent(u ->  System.out.println("The student name is : " + u.getName()));
    }

上述示例用于打印學生姓名，由于ifPresent()方法內部做了null值檢查，調用前無需擔心NPE問題。

3.4  filter()方法

     filter()方法的源碼：

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

filter()方法接受參數為Predicate對象，用于對Optional對象進行過濾，如果符合Predicate的條件，返回Optional對象本身，否則返回一個空的Optional對象。舉例如下：

    public static void filterAge(Student student)
    {
        Optional.ofNullable(student).filter( u -> u.getAge() > 18).ifPresent(u ->  System.out.println("The student age is more than 18."));
    }

上述示例中，實現了年齡大于18的學生的篩選。

3.5  map()方法

     map()方法的源碼：

    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));
        }
    }

map()方法的參數為Function（函數式接口）對象，map()方法將Optional中的包裝對象用Function函數進行運算，并包裝成新的Optional對象（包裝對象的類型可能改變）。舉例如下：

    public static Optional<Integer> getAge(Student student)
    {
        return Optional.ofNullable(student).map(u -> u.getAge()); 
    }

上述代碼中，先用ofNullable()方法構造一個Optional<Student>對象，然后用map()計算學生的年齡，返回Optional<Integer>對象（如果student為null, 返回map()方法返回一個空的Optinal對象）。

3.6  flatMap()方法

     flatMap()方法的源碼：

    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));
        }
    }

跟map()方法不同的是，入參Function函數的返回值類型為Optional<U>類型，而不是U類型，這樣flatMap()能將一個二維的Optional對象映射成一個一維的對象。以3.5中示例功能為例，進行faltMap()改寫如下：

    public static Optional<Integer> getAge(Student student)
    {
        return Optional.ofNullable(student).flatMap(u -> Optional.ofNullable(u.getAge())); 
    }

3.7  orElse()方法

     orElse()方法的源碼：

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

orElse()方法功能比較簡單，即如果包裝對象值非空，返回包裝對象值，否則返回入參other的值（默認值）。如第一章（簡介）中提到的代碼：

    public static String getGender(Student student)
    {
       return Optional.ofNullable(student).map(u -> u.getGender()).orElse("Unkown");
        
    }

3.7  orElseGet()方法

     orElseGet()方法的源碼：

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

orElseGet()方法與orElse()方法類似，區別在于orElseGet()方法的入參為一個Supplier對象，用Supplier對象的get()方法的返回值作為默認值。如：

    public static String getGender(Student student)
    {
        return Optional.ofNullable(student).map(u -> u.getGender()).orElseGet(() -> "Unkown");      
    }

3.8  orElseThrow()方法

     orElseThrow()方法的源碼：

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

orElseThrow()方法其實與orElseGet()方法非常相似了，入參都是Supplier對象，只不過orElseThrow()的Supplier對象必須返回一個Throwable異常，并在orElseThrow()中將異常拋出：

    public static String getGender1(Student student)
    {
        return Optional.ofNullable(student).map(u -> u.getGender()).orElseThrow(() -> new RuntimeException("Unkown"));      
    }

orElseThrow()方法適用于包裝對象值為空時需要拋出特定異常的場景。

四、注意事項

    使用Optional開發時要注意正確使用Optional的“姿勢”，特別注意不要使用3.2節提到的錯誤示范，謹慎使用isPresent()和get()方法，盡量多使用map()、filter()、orElse()等方法來發揮Optional的作用。

感謝各位的閱讀，以上就是“Java8的Optional怎么使用”的內容了，經過本文的學習后，相信大家對Java8的Optional怎么使用這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！