Java8 Optional的使用詳解

Optional介紹

Optional是Jdk1.8提供的一個新類，希望可以通過該類的引入解決令人煩躁的null判斷問題，非常好用，個人理解：這個類是一個包裝類，將要操作的java bean封裝到該類的物件里面，同時將一些常用的判斷邏輯封裝為成員方法，結合lambda語法，實作比較優雅的鏈式呼叫，現在對Optional的API使用做一個簡單的說明，

API介紹

Optional的所有的方法如下圖所示，這些API大致可以分為以下幾類：

1、構建API：構建一個Optional物件；方法有：empty( )、of( )、ofNullable( )；

2、獲取API：獲取Optional物件里包裝的值；方法有：get( )、orElse( )、orElseGet( )、orElseThrow( )；

3、轉換API：將Optional物件里包裝的值轉換成一個新的值；方法有：map( )、flatMap( )；

4、判斷API：對Optional物件里包裝的值做一些邏輯判斷；方法有：filter( )、isPresent( )、ifPresent( )；

API使用方法

首先準備一個pojo類

@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@ToString
public class UserInfo {
    private String username;
    private String password;
    private Integer age;
    private String gender;
}

構建類

	@Test
    public void testBuildOptional() {
        // 構建一個value為null的optional物件；
        Optional<UserInfo> userInfoEmptyOpt = Optional.empty();

        // 構建一個value不可以為null的optional物件，如果of()的入參為null會報空指標例外；
        Optional<UserInfo> userInfoOpt = Optional.of(new UserInfo("阿飛","123456", 15, "man"));

        // 構建一個value可以為null的optional物件；
        Optional<UserInfo> userInfoNullOpt = Optional.ofNullable(null);

        System.out.println(userInfoEmptyOpt);
        System.out.println(userInfoOpt);
        System.out.println(userInfoNullOpt);
        
//        輸出如下：
//        Optional.empty
//        Optional[UserInfo(username=阿飛, password=123456, age=15, gender=man)]
//        Optional.empty
    }

獲取類

	@Test
    public void testGetOptionalValue() {
        Optional<UserInfo> userInfoEmptyOpt = Optional.empty();
        Optional<UserInfo> userInfoOpt = Optional.of(new UserInfo("阿飛","123456", 15, "man"));

        // 直接獲取，注意如果value==null，會報NoSuchElementException例外
        UserInfo userInfo1 = userInfoOpt.get();
        // orElse可以傳入一個UserInfo型別的物件作為默認值;當value!=null時，回傳value值；當value==null時，回傳默認值作為代替；
        UserInfo userInfo2 = userInfoEmptyOpt.orElse(new UserInfo("阿飛1","123456", 15, "man"));
        // orElseGet和orElse不同的是orElseGet可以傳入一段lambda運算式；當value!=null時，回傳value值；當value==null時，使用該lambda回傳的物件作為默認值；
        UserInfo userInfo3 = userInfoEmptyOpt.orElseGet(() -> new UserInfo("阿飛2","123456", 15, "man"));
        // orElseThrow可以傳入一段lambda運算式，lambda回傳一個Exception；當value!=null時，回傳value值；當value==null時，拋出該例外；
        UserInfo userInfo4 = userInfoOpt.orElseThrow(NullPointerException::new);

        System.out.println(userInfo1);
        System.out.println(userInfo2);
        System.out.println(userInfo3);
        System.out.println(userInfo4);

        // 輸出如下：
        // UserInfo(username=阿飛, password=123456, age=15, gender=man)
        // UserInfo(username=阿飛1, password=123456, age=15, gender=man)
        // UserInfo(username=阿飛2, password=123456, age=15, gender=man)
        // UserInfo(username=阿飛, password=123456, age=15, gender=man)
    }

轉換類

	@Test
    public void testMapOptionalValue() {
        Optional<UserInfo> userInfoOpt = Optional.of(new UserInfo("阿飛","123456", 15, "man"));

        // 原來value的型別是UserInfo，經過map轉換為Optional<String>
        Optional<String> username = userInfoOpt.map(UserInfo::getUsername);

        // 當map的入參也是一個Optional時，經過map轉化后會形成Optional<Optional<String>>這種嵌套結構；但flatMap可以把這種嵌套結構打平；
        Optional<Optional<String>> unFlatMap = userInfoOpt.map(user -> Optional.of(user.getUsername()));
        Optional<String> flatMap = userInfoOpt.flatMap(user -> Optional.of(user.getUsername()));

        System.out.println(username);
        System.out.println(unFlatMap);
        System.out.println(flatMap);
        
        // 輸出如下：
        // Optional[阿飛]
        // Optional[Optional[阿飛]]
        // Optional[阿飛]
    }

判斷類

	@Test
    public void testJudgeOptionalValue() {
        Optional<UserInfo> userInfoEmptyOpt = Optional.empty();
        Optional<UserInfo> userInfoOpt = Optional.of(new UserInfo("阿飛", "123456", 15, "man"));

        // filter傳入一個lambda，lambda回傳值為boolean；true:不做任何改變，false:回傳一個空的optional；
        Optional<UserInfo> userInfo = userInfoOpt.filter(user -> "錯誤的密碼".equals(user.getPassword()));
        System.out.println(userInfo);

        // isPresent就是判斷value是不是null；我們在呼叫get之前，一定要先呼叫isPresent，因為直接如果value是null，直接呼叫get會報例外；
        if (userInfoEmptyOpt.isPresent()) {
            UserInfo value = userInfoEmptyOpt.get();
            System.out.println("optional value:" + value);
        } else {
            System.out.println("optional value==null");
        }

        // ifPresent傳入一段lambda，當value!=null時，執行里面的邏輯；當當value==null時，啥都不干；
        userInfoOpt.ifPresent(value -> System.out.println("optional value:" + value));
        
        // 輸入如下：
        // Optional.empty
        // optional value==null
        // optional value:UserInfo(username=阿飛, password=123456, age=15, gender=man)
    }

試一下這些API吧

package com.fly.optional;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import org.junit.Test;
import org.omg.CosNaming.NamingContextPackage.NotFound;

import java.math.BigDecimal;
import java.util.Optional;

public class OptionDemo {

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @ToString
    static class Employee {
        private Long id;
        private String name;
        private Boolean leader;
    }

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @ToString
    static class Leader {
        private Long employeeId;
        private BigDecimal bonus;
    }

    /**
     * 找到ID為1的員工，如果有獎金就列印出來，沒有就列印沒有獎金；
     * @throws NotFound
     */
    @Test
    public void tst() throws NotFound {
        Optional<Leader> leader = Optional.ofNullable(getEmployeeById(1L).filter(Employee::getLeader).map(Employee::getId).flatMap(this::getLeaderByEmployeeId).orElse(null));
        if (leader.isPresent()) {
            Optional.of(leader.map(Leader::getBonus).map(bonus -> String.format("員工ID為1的leader獎金為：%s", bonus)).orElse("員工ID為1的leader也沒有獎金")).ifPresent(System.out::println);
        } else {
            System.out.println("員工ID為1的leader未找到，他可能只是一個基層員工，不配擁有獎金");
        }
    }

    private Optional<Employee> getEmployeeById(Long id) {
        //return Optional.of(new Employee(1L, "大老板", Boolean.TRUE));
        return Optional.of(new Employee(1L, "大老板", Boolean.FALSE));
    }

    private Optional<Leader> getLeaderByEmployeeId(Long employeeId) {
        //return employeeId == 1L ? Optional.of(new Leader(1L, BigDecimal.valueOf(1000000000))) : Optional.empty();
        return employeeId == 1L ? Optional.of(new Leader(1L, null)) : Optional.empty();
    }
}