JAVA8新特性Optional，非空判斷

Optional

java 的 NPE(Null Pointer Exception)所謂的空指針異常搞的頭昏腦漲, 有大佬說過 “防止 NPE，是程序員的基本修養。” 但是修養歸修養，也是我們程序員最頭疼的問題之一，那么我們今天就要盡可能的利用Java8的新特性Optional來盡量簡化代碼同時高效處理 NPE（Null Pointer Exception 空指針異常）

認識Optional並簡單使用

簡單來說，Opitonal 類就是 Java 提供的為了解決大家平時判斷對象是否為空用 會用 null!=obj 這樣的方式存在的判斷，從而令人頭疼導致 NPE（Null Pointer Exception 空指針異常），同時 Optional 的存在可以讓代碼更加簡單，可讀性跟高，代碼寫起來更高效.
正常代碼，判斷對象是否為空

Admin person=new Admin();
if (null==admin){
   return "admin為null";
}
return person;

當我們使用Optional判斷對象是否為空時:

//一、Optional判斷對象是否為空
Admin admin = new Admin();
Optional<Admin> admin1 = Optional.ofNullable(admin);

神奇的Optional類

Optional類內部

首先我們先打開 Optional 的內部, 去一探究竟 先把幾個創建 Optional 對象的方法提取出來：
【這些方法很重要一定要看懂哦，后面都會使用到的】

public final class Optional<T> {
   private static final Optional<?> EMPTY = new Optional<>();
   private final T value;
   //我們可以看到兩個構造方格都是private 私有的
   //說明 我們沒辦法在外面去new出來Optional對象
   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);
    }
    //這個靜態方法大致是 如果參數value為空，則創建空對象，如果不為空，則創建有參對象
   public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }
 }

再做一個簡單的實例展示 與上面對應：

// 1、創建一個包裝對象值為空的Optional對象
Optional<String> optEmpty = Optional.empty();

// 2、創建包裝對象值非空的Optional對象(使用of方法一定要保證對象非空，否則會拋異常)
Optional<String> optOf = Optional.of("optional");

// 3、創建包裝對象值允許為空也可以不為空的Optional對象
Optional<String> optOfNullable1 = Optional.ofNullable(null);
Optional<String> optOfNullable2 = Optional.ofNullable("optional");

我們關於創建 Optional 對象的內部方法大致分析完畢 接下來也正式的進入 Optional 的學習與使用中。

Optional類常用的方法

Optional.get() 方法【返回對象的值】

get()方法源碼：

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

由此我們可以看到get()方法返回的是一個Optional實例值，
也就是說，源碼中如果value的值不為空就會返回value，如果為空，則會直接拋出一個異常 "No value present"
測試實例代碼：

Admin newAdmin = new Admin();
newAdmin.setName("get方法獲取對象值");
Admin Nadmin = Optional.ofNullable(newAdmin).get();

返回數據：
	Nadmin=Admin(id=null, loginName=null, password=null, email=null, name=get方法獲取對象值, mobile=null, departmentId=null, registerDate=null, lastLoginDate=null, status=null, delFlag=null)

Optional.isPresent()方法【判讀是否為空】

isPresent()方法源碼：

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

從源碼上我們可以看到 isPresent方法返回的是一個true/false值，如果判斷的對象不為空着返回false，為空着返回true
測試實例代碼：

Admin admin3 = new Admin();
admin3.setName("isPresent方法判斷是否為空");
Optional.ofNullable(admin3).ifPresent(p -> p.setName(""));	

如果admin對象不為空，則會執行ifPresent方法中的函數，將對象中的name值修改為空字符串。如果對象為空則不會執行函數，並且不會拋空指針異常，optional中已經對NPE（非空驗證）

Optional.filter() 方法 【過濾對象】

filter() 方法源碼展示：

public Optional<T> filter(Predicate<? super T> predicate) {
    Objects.requireNonNull(predicate);
    //如果為空直接返回this
    if (!isPresent())
                return this; else
            //判斷返回本身還是空Optional
    return predicate.test(value) ? this : empty();
}

接受一個對象，然后對他進行條件過濾，如果條件符合則返回 Optional 對象本身，如果不符合則返回空 Optional
測試代碼實例：

Admin admin4 = new Admin();
admin4.setName("filter方法，根據條件過濾對象");
Optional<Admin> adminfilter = Optional.ofNullable(admin4).filter(p -> p.getName().equals("filter方法，根據條件過濾對象"));

Optional.map() 方法 [對象進行二次包裝]

map() 方法將對應 Funcation 函數式接口中的對象，進行二次運算，封裝成新的對象然后返回在 Optional 中 源碼：

public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
        Objects.requireNonNull(mapper);
        //如果為空返回自己
        if (!isPresent())
            return empty();
        else {
        //否則返回用方法修飾過的Optional
            return Optional.ofNullable(mapper.apply(value));
        }
    }

測試代碼用例：

 Admin admin5 = new Admin();
Optional<String>  adminFlatMap= Optional.ofNullable(admin5).map(m -> Optional.ofNullable(m.getName()).orElse("name為空"));

Optional.orElse() 方法 [為空返回對象]

如果包裝對象為空的話，就執行 orElse 方法里的 value，如果非空，則返回寫入對象 源碼:

public T orElse(T other) {
    //如果非空，返回value，如果為空，返回other
    return value != null ? value : other;
}

Optional.orElseGet() 方法 [為空返回 Supplier 對象]

這個與 orElse 很相似，入參不一樣，入參為 Supplier 對象，為空返回傳入對象的. get() 方法，如果非空則返回當前對象 源碼:

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

測試代碼實例：

Optional<Supplier<Person>> sup=Optional.ofNullable(Person::new);
//調用get()方法，此時才會調用對象的構造方法，即獲得到真正對象
Optional.ofNullable(person).orElseGet(sup.get());

Supplier 對象:
Supplier 也是創建對象的一種方式, 簡單來說，Suppiler 是一個接口，是類似 Spring 的懶加載，聲明之后並不會占用內存，只有執行了 get() 方法之后，才會調用構造方法創建出對象創建對象的語法的話就是
語法：Supplier supPerson= Person::new
需要使用時 supPerson.get()即可

Optional.orElseThrow() 方法 [為空返回異常]

如果對象為空，就拋出自定義的異常，如果不為空則返回當前對象，方便異常的處理：

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

測試代碼用例：

//簡單的一個查詢
Member member = memberService.selectByPhone(request.getPhone());
Optional.ofNullable(member).orElseThrow(() -> new ServiceException("沒有查詢的相關數據"));

相似方法區別

orElse() 和 orElseGet() 和 orElseThrow() 的異同點

方法效果類似，如果對象不為空，則返回對象，如果為空，則返回方法體中的對應參數，所以可以看出這三個方法體中參數是不一樣的

• orElse（T 對象）
• orElseGet（Supplier 對象）
• orElseThrow（異常）

orEle()

當optional值不存在時，程序執行orElse()，返回執行后的參數，如果optional值存在時，則orElse()則不會再執行。
對於orElse()和orElseGet()方法的區別，我們可以通過下面optional值得情況可以看出：

• optional有值：

import java.util.Arrays;
import java.util.List;

public class orElseOrElseGetComparation {
    public static void main(String[] args){
        List<Integer> list = Arrays.asList(23,1,3);
        int myElse = list.stream().reduce(Integer::sum).orElse(get("myElse"));
        int myElseGet = list.stream().reduce(Integer::sum).orElseGet(() -> get("myElseGet"));
        System.out.println("myElse的值"+myElse);
        System.out.println("myElseGet的值"+myElseGet);

    }
    public static int get(String name){
        System.out.println(name+"執行了該方法");
        return 1;
    }
}

結果：

myElse執行了該方法
myElse的值27
myElseGet的值27

• optinoal為空時：

import java.util.Arrays;
import java.util.List;

public class orElseOrElseGetComparation {
    public static void main(String[] args){
        List<Integer> list = Arrays.asList();
        int myElse = list.stream().reduce(Integer::sum).orElse(get("myElse"));
        int myElseGet = list.stream().reduce(Integer::sum).orElseGet(() -> get("myElseGet"));
        System.out.println("myElse的值"+myElse);
        System.out.println("myElseGet的值"+myElseGet);

    }
    public static int get(String name){
        System.out.println(name+"執行了該方法");
        return 1;
    }
}

結果：

myElse執行了該方法
myElseGet執行了該方法
myElse的值1
myElseGet的值1

從上面的執行結果我們可以看出orElse()方法在不論optional是否有值都會執行，在optional為空值的情況下orElse和orElseGet都會執行，當optional不為空時，orElseGet不會執行

map()和flatMap()區別

map
map 把數組流中的每一個值，使用所提供的函數執行一遍，一一對應，得到元素個數相同的數組流。

flatMap
flat是扁平的意思。它把數組流中的每一個值，使用所提供的函數執行一遍，一一對應。得到元素相同的數組流。只不過，里面的元素也是一個子數組流。把這些子數組合並成一個數組以后，元素個數大概率會和原數組流的個數不同。

實例

案例：對給定單詞列表 ["Hello","World"],你想返回列表["H","e","l","o","W","r","d"]
第一種方案 map

        String[] words = new String[]{"Hello","World"};
        List<String[]> a = Arrays.stream(words)
                .map(word -> word.split(""))
                .distinct()
                .collect(toList());
        a.forEach(System.out::print);
 代碼輸出為：[Ljava.lang.String;@12edcd21[Ljava.lang.String;@34c45dca 
                  （返回一個包含兩個String[]的list）

這個實現方式是由問題的，傳遞給map方法的lmbda每個單詞生成了一個String[](String列表)。因此，map返回的流實際上是Stream<String[]> 類型的。你真正想要的是用Stream<String>來表示一個字符串。
下方圖是上方代碼stream的運行流程

第二種方式：flatMap（對流扁平化處理）

          String[] words = new String[]{"Hello","World"};
        List<String> a = Arrays.stream(words)
                .map(word -> word.split(""))
                .flatMap(Arrays::stream)
                .distinct()
                .collect(toList());
        a.forEach(System.out::print);
        
        結果輸出：HeloWrd

使用flatMap方法的效果是，各個數組並不是分別映射一個流，而是映射成流的內容，所有使用map(Array::stream)時生成的單個流被合並起來，即扁平化為一個流。
下圖是運用flatMap的stream運行流程:

實戰場景再現

場景 一

在 service 層中查詢一個對象，返回之后判斷是否為空並做處理

//查詢一個對象
Member member = memberService.selectByIdNo(request.getCertificateNo());
//使用ofNullable加orElseThrow做判斷和操作
Optional.ofNullable(member).orElseThrow(() -> new ServiceException("沒有查詢的相關數據"));

場景 二

我們可以在 dao 接口層中定義返回值時就加上 Optional 例如：我使用的是 jpa，其他也同理

public interface LocationRepository extends JpaRepository<Location, String> {
Optional<Location> findLocationById(String id);
}

然在是 Service 中

public TerminalVO findById(String id) {
//這個方法在dao層也是用了Optional包裝了
        Optional<Terminal> terminalOptional = terminalRepository.findById(id);
        //直接使用isPresent()判斷是否為空
        if (terminalOptional.isPresent()) {
        //使用get()方法獲取對象值
            Terminal terminal = terminalOptional.get();
            //在實戰中，我們已經免去了用set去賦值的繁瑣，直接用BeanCopy去賦值
            TerminalVO terminalVO = BeanCopyUtils.copyBean(terminal, TerminalVO.class);
            //調用dao層方法返回包裝后的對象
            Optional<Location> location = locationRepository.findLocationById(terminal.getLocationId());
            if (location.isPresent()) {
                terminalVO.setFullName(location.get().getFullName());
            }
            return terminalVO;
        }
        //不要忘記拋出異常
        throw new ServiceException("該終端不存在");
    }

Optional 使用注意事項

Optional 真么好用，真的可以完全替代 if 判斷嗎？
我想這肯定是大家使用完之后 Optional 之后可能會產生的想法，答案是否定的
舉一個最簡單的栗子：
例子 1：
如果我只想判斷對象的某一個變量是否為空並且做出判斷呢？

Person person=new Person();
person.setName("");
persion.setAge(2);
//普通判斷
if(StringUtils.isNotBlank(person.getName())){
  //名稱不為空執行代碼塊
}
//使用Optional做判斷
Optional.ofNullable(person).map(p -> p.getName()).orElse("name為空");

我覺得這個例子就能很好的說明這個問題，只是一個很簡單判斷，如果用了 Optional 我們還需要考慮包裝值，考慮代碼書寫，考慮方法調用，雖然只有一行，但是可讀性並不好，如果別的程序員去讀，我覺得肯定沒有 if 看的明顯.

jdk1.9 對 Optional 優化(待補充)

首先增加了三個方法:
or()、ifPresentOrElse() 和 stream()
or() 與 orElse 等方法相似，如果對象不為空返回對象，如果為空則返回 or() 方法中預設的值。
ifPresentOrElse() 方法有兩個參數：一個Consumer和一個 Runnable。如果對象不為空，會執行 Consumer 的動作，否則運行 Runnable。相比 ifPresent（）多了 OrElse 判斷。
stream() 將 Optional 轉換成 stream，如果有值就返回包含值的 stream，如果沒值，就返回空的 stream。