引言

在文章的開頭，先說下NPE問題，NPE問題就是，我們在開發中經常碰到的NullPointerException.假設我們有兩個類，他們的UML類圖如下圖所示

在這種情況下，有如下代碼

user.getAddress().getProvince();

這種寫法，在user為null時，是有可能報NullPointerException異常的。為了解決這個問題，于是采用下面的寫法

if(user!=null){
Addressaddress=user.getAddress();
if(address!=null){
Stringprovince=address.getProvince();
}
}

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

一個連載多年還在繼續更新的免費教程：http://blog.didispace.com/spring-boot-learning-2x/

API介紹

先介紹一下API，與其他文章不同的是，本文采取類比的方式來講，同時結合源碼。而不像其他文章一樣，一個個API羅列出來，讓人找不到重點。

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

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

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

那么，of(T value)的源碼如下

publicstaticOptionalof(Tvalue){
returnnewOptional<>(value);
}

也就是說of(T value)函數內部調用了構造函數。根據構造函數的源碼我們可以得出兩個結論:

• 通過of(T value)函數所構造出的Optional對象，當Value值為空時，依然會報NullPointerException。
• 通過of(T value)函數所構造出的Optional對象，當Value值不為空時，能正常構造Optional對象。

除此之外呢，Optional類內部還維護一個value為null的對象，大概就是長下面這樣的

publicfinalclassOptional<T>{
//省略....
privatestaticfinalOptionalEMPTY=newOptional<>();
privateOptional(){
this.value=null;
}
//省略...
publicstaticOptionalempty(){
@SuppressWarnings("unchecked")
Optionalt=(Optional)EMPTY;
returnt;
}
}

那么，empty（）的作用就是返回EMPTY對象。

好了鋪墊了這么多，可以說ofNullable(T value)的作用了，上源碼

publicstaticOptionalofNullable(Tvalue){
returnvalue==null?empty():of(value);
}

好吧，大家應該都看得懂什么意思了。相比較of(T value)的區別就是，當value值為null時，of(T value)會報NullPointerException異常；ofNullable(T value)不會throw Exception，ofNullable(T value)直接返回一個EMPTY對象。

那是不是意味著，我們在項目中只用ofNullable函數而不用of函數呢?

不是的，一個東西存在那么自然有存在的價值。當我們在運行過程中，不想隱藏NullPointerException。而是要立即報告，這種情況下就用Of函數。但是不得不承認，這樣的場景真的很少。博主也僅在寫junit測試用例中用到過此函數。

2、orElse(T other)，orElseGet(Supplier other)和orElseThrow(Supplier exceptionSupplier)

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

@Test
publicvoidtest(){
Useruser=null;
user=Optional.ofNullable(user).orElse(createUser());
user=Optional.ofNullable(user).orElseGet(()->createUser());

}
publicUsercreateUser(){
Useruser=newUser();
user.setName("zhangsan");
returnuser;
}

這兩個函數的區別：當user值不為null時，orElse函數依然會執行createUser()方法，而orElseGet函數并不會執行createUser()方法，大家可自行測試。

至于orElseThrow，就是value值為null時,直接拋一個異常出去，用法如下所示

Useruser=null;
Optional.ofNullable(user).orElseThrow(()->newException("用戶不存在"));

3、map(Function mapper)和flatMap(Function> mapper)

這兩個函數放在一組記憶，這兩個函數做的是轉換值的操作。

直接上源碼

publicfinalclassOptional<T>{
//省略....
publicOptionalmap(FunctionsuperT,?extendsU>mapper){
Objects.requireNonNull(mapper);
if(!isPresent())
returnempty();
else{
returnOptional.ofNullable(mapper.apply(value));
}
}
//省略...
publicOptionalflatMap(FunctionsuperT,Optional>mapper){
Objects.requireNonNull(mapper);
if(!isPresent())
returnempty();
else{
returnObjects.requireNonNull(mapper.apply(value));
}
}
}

publicclassUser{
privateStringname;
publicStringgetName(){
returnname;
}
}

Stringcity=Optional.ofNullable(user).map(u->u.getName()).get();

publicclassUser{
privateStringname;
publicOptionalgetName(){
returnOptional.ofNullable(name);
}
}

Stringcity=Optional.ofNullable(user).flatMap(u->u.getName()).get();

publicfinalclassOptional<T>{
//省略....
publicbooleanisPresent(){
returnvalue!=null;
}
//省略...
publicvoidifPresent(ConsumersuperT>consumer){
if(value!=null)
consumer.accept(value);
}
}

if(user!=null){
//TODO:dosomething
}

Useruser=Optional.ofNullable(user);
if(Optional.isPresent()){
//TODO:dosomething
}

Optional.ofNullable(user).ifPresent(u->{
//TODO:dosomething
});

publicfinalclassOptional<T>{
//省略....
Objects.requireNonNull(predicate);
if(!isPresent())
returnthis;
else
returnpredicate.test(value)?this:empty();
}

Optionaluser1=Optional.ofNullable(user).filter(u->u.getName().length()<6);

publicStringgetCity(Useruser)throwsException{
if(user!=null){
if(user.getAddress()!=null){
Addressaddress=user.getAddress();
if(address.getCity()!=null){
returnaddress.getCity();
}
}
}
thrownewExcpetion("取值錯誤");
}

publicStringgetCity(Useruser)throwsException{
returnOptional.ofNullable(user)
.map(u->u.getAddress())
.map(a->a.getCity())
.orElseThrow(()->newException("取指錯誤"));
}

if(user!=null){
dosomething(user);
}

Optional.ofNullable(user)
.ifPresent(u->{
dosomething(u);
});

publicUsergetUser(Useruser)throwsException{
if(user!=null){
Stringname=user.getName();
if("zhangsan".equals(name)){
returnuser;
}
}else{
user=newUser();
user.setName("zhangsan");
returnuser;
}
}

publicUsergetUser(Useruser){
returnOptional.ofNullable(user)
.filter(u->"zhangsan".equals(u.getName()))
.orElseGet(()->{
Useruser1=newUser();
user1.setName("zhangsan");
returnuser1;
});
}