Java Optional的判空操作詳解

Posted on by

Optional判空

JAVA在1.8版本推出Optional，官方文檔將其描述為可能包含或不包含非空值的容器對象，目前Optional用於避免程序出現異常NullPointerException。

代碼模擬

// 下面所有類省略set，get方法
public class Employee {
    private String employeeName;
    private Team team;
}

public class Team {
    private String teamName;
    private Department department;

    public Team(String teamName) {
        this.teamName = teamName;
    }
}

public class Department {
    private String departmentName;
    private Company company;
}

public class Company {
    private String companyName;
}

測試代碼

// 在創建時因為沒有初始化Team對象的Department屬性，導致後續調用空指針
public void testCompany(){
    Employee employee = new Employee();
    employee.setEmployeeName("zhangsan");
    employee.setTeam(new Team("xxx產品組"));
    System.out.println(employee.getTeam().getDepartment().getCompany().getCompanyName());
}

這時如果我們采用傳統方式一般判空代碼如下

public void testCompanyAvoidNPE(){
    Employee employee = new Employee();
    employee.setEmployeeName("zhangsan");
    employee.setTeam(new Team("xxx產品組"));
    Team team = employee.getTeam();
    if (team == null){
        System.out.println("異常拉，參數為空!");
        return;
    }
    Department department = team.getDepartment();
    if (department == null){
        System.out.println("異常拉，參數為空!");
        return;
    }
    Company company = department.getCompany();
    if (company == null){
        System.out.println("異常拉，參數為空!");
        return;
    }
    String companyName = company.getCompanyName();
    System.out.println(companyName);
}

顯然這種判空代碼造成瞭業務代碼膨脹，代碼可讀性極低，所以在這種場景下我們需要學習1.8推出的判空容器對象Optional。

Optional常用方法

創建 Optional 對象

JAVA提供瞭三個靜態方法用於構建Optional對象如下所示

返回值 方法和描述
static <T> Optional<T> empty()  返回一個空的 Optional實例。
static <T> Optional<T> of(T value)  返回具有 Optional的當前非空值的Optional。
static <T> Optional<T> ofNullable(T value)  返回一個 Optional指定值的Optional，如果非空，則返回一個空的  Optional 。 
public void createOptionalObject(){
    System.out.println(Optional.empty());
    // 傳null報空指針
    // System.out.println(Optional.of(null));
    System.out.println(Optional.of(new String("1111")));
    // 傳null調用Optional.empty()
    System.out.println(Optional.ofNullable(null));
    System.out.println(Optional.ofNullable(new Content("111","測試內容")));
}

class Content {
    private String id;
    private String value;

    public Content() {
    }

    public Content(String id, String value) {
        this.id = id;
        this.value = value;
    }
    // 省略get，set方法
}

執行結果如下

Optional.empty
Optional[1111]
Optional.empty
Optional[Content{id='111', value='測試內容'}]

在真正使用時建議使用ofNullable，因為它能處理空值或者非空值，代碼如下

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

常用功能方法

方法名 返回值 功能描述
isPresent() boolean 判斷Optional對象是否存在，存在true不存在false
ifPresent(Consumer<? super T> consumer) void 如果Optional對象存在執行consumer消費型接口，不存在不執行
get T 返回Optional對象封裝的對象T數據，註意實際對象可能為空會拋出異常
orElse(T other) T 如果Optional對象存在則返回封裝的對象數據，如果不存在返回T other數據，相當於不存在給默認值
orElseGet(Supplier<? extends T> other) T 是orElse方法的升級版，區別在於orElse方法傳入的是一個固定默認值，而此方法是一個供給型函數方法，如果Optional對象為空則執行other的方法邏輯
orElseThrow(Supplier<? extends X> exceptionSupplier) <X extends Throwable>T 一樣是orElse方法的升級版，當Optional對象為空執行exceptionSupplier方法，最後拋出異常
filter(Predicate<? super T> predicate) Optional<T> 當Optional對象滿足predicate斷言函數中的匹配規則則返回，否則返回空Optional
map(Function<? super T,? extends U> mapper) <U> Optional<U> 能夠將Optional的對象值處理轉換為另一個實例對象值，並生成新類型的Optional對象，如果生成的新對象為null，則返回一個空Optional對象
flatMap(Function<? super T,Optional<U>> mapper) <U> Optional<U> 和map類似，不過map操作的是具體對象，而flatMap返回的是Optional封裝過的對象

代碼演示如下

    public void testOptionFunction(){
        //===============================isPresent()================================
        // false
        System.out.println(Optional.empty().isPresent());
        // Optional[Content{id='222', value='測試'}]
        System.out.println(Optional.ofNullable(new Content("222","測試")));

        //===============================ifPresent()================================
        // 不為空打印：Content{id='222', value='測試'}  為空不執行
        Optional.ofNullable(new Content("222","測試")).ifPresent(e->{
            System.out.println("不為空打印："+e);
        });

        //===============================get()================================
        // NoSuchElementException: No value present
        try {
            System.out.println(Optional.empty().get());
        }catch (Exception e){
            e.printStackTrace();
        }
        // Content{id='222', value='測試'}
        System.out.println(Optional.ofNullable(new Content("222","測試")).get());

        //===============================orElse()================================
        // Content{id='0', value='默認'}
        System.out.println(Optional.empty().orElse(new Content("0","默認")));

        //===============================orElseGet()================================
        // Content{id='333', value='測試orElseGet'}
        System.out.println(Optional.empty().orElseGet(() -> {
            Content content = new Content("333", "測試orElseGet");
            return content;
        }));

        // Content{id='222', value='測試'}
        System.out.println(Optional.ofNullable(new Content("222", "測試")).orElseGet(() -> {
            Content content = new Content("444", "測試orElseGet");
            return content;
        }));

        //===============================orElseThrow()================================
        // java.lang.Exception: 參數為空
        try {
            Optional.empty().orElseThrow(()->{
               return new Exception("參數為空");
            });
        } catch (Exception e) {
            e.printStackTrace();
        }

        //===============================filter()================================
        // "555".equals(e.getId());   Optional[Content{id='555', value='測試'}]
        // "5565".equals(e.getId());  Optional.empty
        System.out.println(Optional.ofNullable(new Content("555", "測試")).filter(e -> {
            return "5565".equals(e.getId());
        }));
    }

map和flatMap

public void testOptionMapFunction(){
    Optional<Content> optionalContent = Optional.ofNullable(new Content("777","測試Map"));

    Optional<Content> optionalContent1 = optionalContent.map(e -> {
        String id = e.getId();
        String value = e.getValue();
        return e;
    });

    Optional<Content> optionalContent2 = optionalContent.flatMap(e -> {
        String id = e.getId();
        String value = e.getValue();
        // 不同點在這裡，一個是可以轉換為另一個實例對象，一個是轉換為Optional包裝對象
        return Optional.of(e);
    });
    // 最終效果實現效果類似
    System.out.println(optionalContent1);
    System.out.println(optionalContent2);
}

使用Optional一定比null好嗎

這個顯然是不對的，如果使用方式如下所示，其實和null的直接判空沒有區別

public static void main(String[] args) {
    Optional<Content> optionalContent = Optional.ofNullable(null);
    // 直接報錯
    optionalContent.get();
}

// 升級寫法
public static void main(String[] args) {
    Optional<Content> optionalContent = Optional.ofNullable(null);
    // 非空判斷
    if (optionalContent.isPresent()){
        System.out.println(optionalContent.get());
    }
}

null的直接判空

public static void main(String[] args) {
    Content content = new Content();
    if (content != null){
        System.out.println(content);
    }
}

正確寫法如下所示

public static void main(String[] args) {
    Optional<Content> optionalContent = Optional.ofNullable(null);
    // 非空時執行消費型接口裡面的邏輯
    optionalContent.ifPresent(content -> {
        System.out.println(content);
    });
}

到這裡有人可能說，如果if{}else{}裡面都需要寫邏輯如何處理呢

public static void main(String[] args) {
    Optional<Content> optionalContent = Optional.ofNullable(null);
    Content content = optionalContent.map(e -> {
        // 做一些業務
        // 返回值可以為任意類型值，可以返回字符串，不過orElseGet需要返回字符串保持一致即可
        return e;
    }).orElseGet(() -> {
        // 做一些業務
        return new Content("0", "默認值");
    });
    System.out.println(content);
}

Optional 使用場景

減少繁瑣的非空判斷

如前面提到的testCompanyAvoidNPE方法中的例子，就可以采用Optional來簡化

public void testCompanyAvoidNPE2(){
    Employee employee = new Employee();
    employee.setEmployeeName("zhangsan");
    employee.setTeam(new Team("xxx產品組"));
    // 這裡相當於是鏈式操作
    String companyName = Optional.ofNullable(employee)
        .map(employee1 -> employee1.getTeam())
        .map(team -> team.getDepartment())
        .map(department -> department.getCompany())
        .map(company -> company.getCompanyName())
        .orElse("no company");
    System.out.println(companyName);
}

設置默認值兜底

// 原始方法
public String setDefaultValue1(Content content){
    if (ObjectUtils.isEmpty(content)){
        return "0";
    }
    if (StringUtils.isEmpty(content.getId())){
        String id = "0";
        content.setId(id);
    }
    return content.getId();
}

// 采用Optional
public String setDefaultValue2(Content content){
    String id = Optional.ofNullable(content)
        .map(content1 -> content1.getId())
        .orElse("0");
    return id;
}

Optional 盡量隻用作方法的返回類型

註意我們采用Optional的最終目的是避免程序中出現null對象異常的情況，所以我們封裝方法的時候可以采用Optional 作為方法的返回值類型，但也要註意Optional雖好但不要濫用，適當使用即可。

以上就是Java Optional的判空操作詳解的詳細內容，更多關於Java Optional判空操作的資料請關註WalkonNet其它相關文章！

推薦閱讀：