Java 8 Optional 類

Java 8 新特性

Optional 類是一個可以為null的容器物件。如果值存在則isPresent()方法會返回true，呼叫get()方法會返回該物件。

Optional 是個容器：它可以儲存型別T的值，或者僅僅儲存null。Optional提供很多有用的方法，這樣我們就不用顯式進行空值檢測。

Optional 類的引入很好的解決空指標異常。

類宣告

以下是一個 java.util.Optional<T> 類的宣告：

publicfinalclassOptional<T> extendsObject

類方法

序號 方法 & 描述
1 static <T> Optional<T> empty()

返回空的 Optional 例項。
2 boolean equals(Object obj)

判斷其他物件是否等於 Optional。
3 Optional<T> filter(Predicate<? super <T> predicate)

如果值存在，並且這個值匹配給定的 predicate，返回一個Optional用以描述這個值，否則返回一個空的Optional。
4 <U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper)

如果值存在，返回基於Optional包含的對映方法的值，否則返回一個空的Optional
5 T get()

如果在這個Optional中包含這個值，返回值，否則丟擲異常：NoSuchElementException
6 int hashCode()

返回存在值的雜湊碼，如果值不存在 返回 0。
7 void ifPresent(Consumer<? super T> consumer)

如果值存在則使用該值呼叫 consumer , 否則不做任何事情。
8 boolean isPresent()

如果值存在則方法會返回true，否則返回 false。
9 <U>Optional<U> map(Function<? super T,? extends U> mapper)

如果有值，則對其執行呼叫對映函式得到返回值。如果返回值不為 null，則建立包含對映返回值的Optional作為map方法返回值，否則返回空Optional。
10 static <T> Optional<T> of(T value)

返回一個指定非null值的Optional。
11 static <T> Optional<T> ofNullable(T value)

如果為非空，返回 Optional 描述的指定值，否則返回空的 Optional。
12 T orElse(T other)

如果存在該值，返回值， 否則返回 other。
13 T orElseGet(Supplier<? extends T> other)

如果存在該值，返回值， 否則觸發 other，並返回 other 呼叫的結果。
14 <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)

如果存在該值，返回包含的值，否則丟擲由 Supplier 繼承的異常
15 String toString()

返回一個Optional的非空字串，用來除錯

注意： 這些方法是從 java.lang.Object 類繼承來的。

Optional 例項

我們可以通過以下例項來更好的瞭解 Optional 類的使用：

import lombok.Data;

import lombok.extern.slf4j.Slf4j;

import java.util.Arrays;

import java.util.List;

import java.util.Optional;

import java.util.stream.Collectors;

@Slf4j

public class Test {

    //任務：獲取user中age>18，money>80

    public static void main(String[] args) {

        User user1 = new User("lisi1", 25, 100);

        User user2 = new User("lisi2", 11, 70);

        User user3 = new User("lisi4", null, 77);

        User user4 = new User("lisi5", 25, null);

        User user5 = new User("lisi6", 25, 46);

        User user6 = null;

        List<User> users = Arrays.asList(user1, user2, user3, user4, user5, user6);

        List<User> list = users.parallelStream().filter(user -> {

            //user不能為空 　　　　　　　

            // Optional<User> optional = Optional.of(user);

            Optional<User> optional = Optional.ofNullable(user);

            log.info("do orElse()");

            //為空返回orElse中結果，無論是否為空都會執行到

            User user10 = optional.orElse(getUser());

            log.info("do orElseGet");

            // 為空返回orElse中結果，為空都才會執行到

            User user11 = optional.orElseGet(Test::getUser);

            log.info("do filter");

            //filter返回的是Optional

            Integer score = optional.filter(s -> s.name.length() > 2).map(User::getMoney).orElse(0);

            //不為空執行ifPresent

            log.info("do ifPresent");

            optional.ifPresent(user12 -> {

                log.info("user{}:", user12);

            });

            if (!optional.isPresent()) {

                return false;

            }

            //獲取到的值為空返回else的值

            Integer age = optional.map(User::getAge).orElse(0);

            Integer money = optional.map(User::getMoney).orElse(0);

            return age > 18 && money > 80;

        }).collect(Collectors.toList());

        log.info("list:{}", list);

    }

    private static User getUser() {

        log.debug("Creating New User");

        return new User();

    }

    @Data

    private static class User {

        public User() {

        }

        public User(String name, Integer age, Integer money) {

            this.name = name;

            this.age = age;

            this.money = money;

        }

        String name;

        Integer age;

        Integer money;

    }

}