public class OptionalDemo {
    private static final String DEFAULT_NAME = "javalover";

    public static void main(String[] args) {
      // 傳入null，以身試法  
      getName(null);
    }
    // 取出c.name
    public static void getName(C c){
        // 舊代碼 Java8之前
        String name = (c!=null ? c.getName() : DEFAULT_NAME);
        System.out.println("old: "+name);
        // 新代碼 Java8之后（下面的三個操作方法后面會介紹，這里簡單了解下）
        String nameNew = Optional
            				// 工廠方法，創(chuàng)建Optional<C>對象，如果c為null，則創(chuàng)建空的Optional<C>對象
                            .ofNullable(c)
            				// 提取name，這里要注意，即使c==null,這里也不會拋出NPE，而是返回空的Optional<String>，所以在處理數(shù)據(jù)時，我們不需要擔(dān)心空指針異常
                            .map(c1->c1.getName())
            				// 獲取optional的屬性值，如果為null，則返回給定的實(shí)參DEFAULT_NAME
                            .orElse(DEFAULT_NAME);

        System.out.println("new: "+nameNew);
    }
}
class C{
    private String name;

    public C(String name) {
        this.name = name;
    }
  // 省略getter/setter
}

乍一看，好像Java8之前的舊代碼更合適啊，只需要一個三目運(yùn)算符

再看Optional操作，發(fā)現(xiàn)并沒有那么簡潔

是這樣的，如果只是一層判斷，那普通的if判斷做起來更方便；

但是如果嵌套兩層呢，比如b.getC().getName()？

下面我們就看下，兩層嵌套會怎么樣

例子2：現(xiàn)多了一個B類（依賴C類），我們要從對象B中提取C的屬性name，即b.getC().getName()

public static void getName2(B b){
        // 舊代碼
        String name = (b!=null ? ( b.getC()!=null ? b.getC().getName() : DEFAULT_NAME) : DEFAULT_NAME);
        // 新代碼
        String nameNew = Optional
                .ofNullable(b)
                .map(b1->b1.getC())
                .map(c1->c1.getName())
                .orElse(DEFAULT_NAME);
        System.out.println(nameNew);
    }

class B{
    private C c;

    public B(C c) {
        this.c = c;
    }
  // 省略getter/setter
}

這次不管是乍一看，還是一直看，都是Optional更勝一籌

例子3：現(xiàn)多了一個A類（依賴B類），我們要提取a.getB().getC().getName()

等等等，省略號

意思到就行，反正要說的就是單從判空來看的話，Optional肯定是好過三目運(yùn)算符的（if/else這里就不舉了，它的嵌套只會更多）

3. 核心操作

因?yàn)镺ptional主要是操作數(shù)據(jù)（類似數(shù)據(jù)庫操作），所以我們這里從數(shù)據(jù)的角度來進(jìn)行分析

這里我們可以分為三種操作：保存數(shù)據(jù)、處理數(shù)據(jù)、獲取數(shù)據(jù)

保存數(shù)據(jù)：

（沒有默認(rèn)值）public static <T> Optional<T> of(T value) ：填充 T value 到 Optional 的屬性中；如果 value==null，則拋出NPE
（默認(rèn)null）public static <T> Optional<T> ofNullable(T value) ：填充 T value 到 Optional 的屬性中；如果引用為null，則填充null
（構(gòu)造一個空的Optional）public static<T> Optional<T> empty()：單純地創(chuàng)建一個數(shù)據(jù)為null的空Optional，即直接填充null到 Optional 的屬性中【不常用】

處理數(shù)據(jù)：

（提取）public Optional map(Function<? super T, ? extends U> mapper) ：提取Optional中屬性T的某個屬性值U，并將U填充到新的Optional中并返回
（過濾）public Optional<T> filter(Predicate<? super T> predicate) ：過濾Optional中屬性T的某個屬性值，符合條件則將T填充到新的Optional中并返回
（扁平化提?。?code>public Optional flatMap(Function<? super T, Optional> mapper)：提取Optional中屬性T的某個屬性Optional，直接返回

獲取數(shù)據(jù)：

public T orElse(T other) ：獲取數(shù)據(jù)，如果數(shù)據(jù)為null，則返回T other
public T orElseGet(Supplier<? extends T> other)：獲取數(shù)據(jù)，如果數(shù)據(jù)為null，則通過函數(shù)式接口other返回一個新的數(shù)據(jù)T
public T get() ：獲取數(shù)據(jù)，如果數(shù)據(jù)為null，則報NPE【不常用】

上面這些操作中，不常用的就是get()和empty()

其他的就不舉了，這里主要說下map()和flatMap()

如下圖所示：

map()主要是提取Optional中的屬性C的屬性name，然后再包裝到新的Optional

輸入Optional<C>，輸出Optional<String>（即Optional<c.name>）

String nameNew = Optional
                    .ofNullable(c)
                    .map(c1->c1.getName())
                    .orElse("xxx");

flatMap()主要是提取Optional中的屬性B的Optional<C>屬性中的C的值，然后再包裝到新的Optional

輸入Optional,輸出Optional<C>

public class FlatMapDemo {
    private static final String DEFAULT_NAME = "javalover";

    public static void main(String[] args) {
        getName(null);
    }

    // 取出 b.c.name
    public static void getName(B b){
        C c = Optional
                .ofNullable(b)
            	// 這里扁平化處理，提取Optional<C>中的C
            	// 如果用map，則返回的是Optional<Optional<C>>
                .flatMap(b->b.getC())
                .orElse(new C("xxx"));
        System.out.println(c.getName());
    }
}

class B{
    private Optional<C> c;

    public Optional<C> getC() {
        return c;
    }

    public void setC(C c) {
        this.c = Optional.ofNullable(c);
    }
}

class C{
    private String name;

    public C(String name) {
        this.name = name;
    }
    // 省略getter/setter
}

4. 應(yīng)用

從規(guī)范角度來講，是為了代碼清晰，一看用Optional<T>變量，就知道T可能為null；

從編碼角度來講，主要是應(yīng)用在非空判斷；但是實(shí)際場景的話，有兩個

沒有用Optional進(jìn)行包裹的參數(shù)：比如上面講到的例子，傳來的參數(shù)就是普通對象，我們就需要自己用Optional容器來包裹傳來的參數(shù)，然后進(jìn)行后續(xù)操作

// 取出c.name
public static void getName(C c){
    // 自己手動包裝 Optional<C>
    String nameNew = Optional
        .ofNullable(c)
        .map(c1->c1.getName())
        .orElse(DEFAULT_NAME);

    System.out.println("new: "+nameNew);
}

有用Optional進(jìn)行包裹的參數(shù)：比如數(shù)據(jù)庫查詢時，我們可以用Optional來包裹查詢的結(jié)果并返回，這樣我們分析結(jié)果的時候，只需要通過orElse()來獲取，同時還可以設(shè)定默認(rèn)值

// 返回Optional<Car>，通過.orElse(defaultCar)就可以獲取返回值，如果返回值為null，還可以設(shè)定一個默認(rèn)值defaultCar
Optional<Car> selectOne(SelectStatementProvider selectStatement);

總結(jié)

Optional是什么：一個容器，存放一個對象，對象可以為null
沒它 VS 有它：看場景
- 如果只是單個的if/else判斷，那就沒它會好點(diǎn)；
- 如果嵌套比較多，或者本來傳來的數(shù)據(jù)就是Optional類型，那肯定是Optional合適
核心操作：不常用的這里就不寫了
- 保存數(shù)據(jù)：工廠方法 of()和ofNullable()
- 處理數(shù)據(jù)：map(), filter(), flatMap()
- 獲取數(shù)據(jù)：orElse()
應(yīng)用：主要用在非空判斷，實(shí)際場景的話，我們可以用在數(shù)據(jù)庫查詢語句中