Java8之妙用Optional解決判斷Null為空的問題

先來鋪墊下已經存在的 Java8 定義的函數式接口：

Java8 Optional庫實用操作【簡化if else】

我們基本不需要定義自己的函數式接口，Java8 已經給我們提供了大量的默認函數式接口，基本夠用，在 rt.jar 包的 java.util.function 目錄下可以看到所有默認的函數式接口，大致分為幾類：

• Function<T,R> T 作為輸入，返回的 R 作為輸出
• Predicate<T> T 作為輸入 ，返回 boolean 值的輸出
• Consumer<T> T 作為輸入 ，沒有輸出
• Supplier<R> 沒有輸入 , R 作為輸出
• BinaryOperator<T> 兩個 T 作為輸入 ，T 同樣是輸出
• UnaryOperator<T> 是 Function 的變種 ，輸入輸出者是 T

我們先來看看示例：

其它的都是上面幾種的各種擴展，只為更方便的使用，下面演示示例，你可以把其當成正常的接口使用，由用戶使用 Lambda 傳入。

// hello world 示例
Function<String,String> function = (x) -> {return x+"Function";};
System.out.println(function.apply("hello world"));  // hello world Function

UnaryOperator<String> unaryOperator = x -> x + 2;
System.out.println(unaryOperator.apply("9420-"));   // 9420-2

// 判斷輸入值是否為偶數示例
Predicate<Integer> predicate = (x) ->{return x % 2 == 0 ;};
System.out.println(predicate.test(1));              // false

// 這個沒有返回值
Consumer<String> consumer = (x) -> {System.out.println(x);};
consumer.accept("hello world ");                    // hello world

// 這個沒有輸入 
Supplier<String> supplier = () -> {return "Supplier";};
System.out.println(supplier.get());                 // Supplier

// 找出大數
BinaryOperator<Integer> bina = (x, y) ->{return x > y ? x : y;};
bina.apply(1,2);                                    // 2 

接下來我們進入本文要講解的內容：

let's go ~

if(user!=null){
    Address address = user.getAddress();
    if(address!=null){
        String province = address.getProvince();
    }
}

這種寫法是比較丑陋的，為了避免上述丑陋的寫法，讓丑陋的設計變得優雅。JAVA8提供了Optional類來優化這種寫法，接下來的正文部分進行詳細說明:

實戰：

使用最多：

API介紹

1、Optional(T value),empty(),of(T value),ofNullable(T value)

這四個函數之間具有相關性，因此放在一組進行記憶。

先說明一下，Optional(T value)，即構造函數，它是private權限的，不能由外部調用的。其余三個函數是public權限，供我們所調用。那么，Optional的本質，就是內部儲存了一個真實的值，在構造的時候，就直接判斷其值是否為空。好吧，這么說還是比較抽象。直接上Optional(T value)構造函數的源碼，如下圖所示

2、orElse(T other)，orElseGet(Supplier<? extends T> other)和orElseThrow(Supplier<? extends X> exceptionSupplier)

這三個函數放一組進行記憶，都是在構造函數傳入的value值為null時，進行調用的。orElse和orElseGet的用法如下所示，相當於value值為null時，給予一個默認值:

@Test
public void test() {
    User user = null;
    user = Optional.ofNullable(user).orElse(createUser());
    user = Optional.ofNullable(user).orElseGet(() -> createUser());
     Object orElseGet = Optional.ofNullable(inss).orElseGet(()-> "sssssss");
}
public User createUser(){
    User user = new User();
    user.setName("zhangsan");
    return user;
}

 

 

判斷list里的元素:

public static void main(String[] args) {
        Address a1 = new Address("成都");
        Address a2 = new Address("南京");
        Address a3 = new Address("天津");
        Address a4 = new Address("北京");
        List<Address> list = new ArrayList<>();
        List<Address> list1 = new ArrayList<>();
        list.add(a1);list.add(a2);list.add(a3);list.add(a4);
        List<Address> collect = list.stream().filter(a->
            Optional.ofNullable(a).map(address -> address.getCity().contains("京")).get()
        )
        .peek(a -> {
            a.setCity(a.getCity().replace("京","精"));
            list1.add(a);
        })
        .collect(Collectors.toList());
        System.out.println(collect);
        System.out.println(list1);
    }

結果：

[Address{city='南精'}, Address{city='北精'}]
[Address{city='南精'}, Address{city='北精'}]