Java8带来的函数式编程特性对于习惯命令式编程的程序员来说还是有一定的障碍的，我们只有深入了解这些机制的方方面面才能运用自如。Null的处理在JAVA编程中是出了try catch之外的另一个头疼的问题，需要大量的非空判断模板代码，程序逻辑嵌套层次太深。尤其是对集合的使用，需要层层判空。

首先来看下Optional类的结构图：

1,Optional拥有两个字段

1. /** 
2.      * Common instance for {@code empty()}. 
3.      */ 
4.     private static final Optional<?> EMPTY = new Optional<>(); 
5.  
6.     /** 
7.      * If non-null, the value; if null, indicates no value is present 
8.      */ 
9.     private final T value;  

1)EMPTY持有某个类型的空值结构,调用empty()返回的即是该实例

1. public static<T> Optional<T> empty() { 
2.         @SuppressWarnings("unchecked") 
3.         Optional<T> t = (Optional<T>) EMPTY; 
4.         return t; 
5.     }  

2)T vaule是该结构的持有的值

2,Optional的方法

1)构造函数

1. private Optional() { 
2.         this.value = null; 
3.     } 
4. private Optional(T value) { 
5.         this.value = Objects.requireNonNull(value); 
6.     }  

Optional(T value)如果vaule为null就会抛出NullPointer异常,所以对于使用的场景这两个构造器都适用.

2)生成Optional对象

有两个方法 of(T)和ofNullable(T)

1. public static <T> Optional<T> of(T value) { 
2.         return new Optional<>(value); 
3.     } 
4.  
5.  public static <T> Optional<T> ofNullable(T value) { 
6.         return value == null ? empty() : of(value); 
7.     }  

of是直接调用的构造函数,因此如果T为null则会抛出空指针异常

ofNullable对null进行了处理,会返回EMPTY的实例,因此不会出现异常

所以只有对于明确不会为null的对象才能直接使用of

3)获取Optional对象的值

需要摈弃的使用方式

if(value.isPresent){

....

}else{

T t = value.get();

}

这种使用方式无异于传统的if(vaule != null)

正确的使用姿势:

orElse:如果值为空则返回指定的值

orElseGet:如果值为空则调用指定的方法返回

orElseThrow:如果值为空则直接抛出异常

1. public T orElse(T other) { 
2.         return value != null ? value : other; 
3.     } 
4.  
5.     public T orElseGet(Supplier<? extends T> other) { 
6.         return value != null ? value : other.get(); 
7.     } 
8.  
9.     public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X { 
10.         if (value != null) { 
11.             return value; 
12.         } else { 
13.             throw exceptionSupplier.get(); 
14.         } 
15.     }  

一般我们使用orElse来取值,如果不存在返回默认值.

4)Optional的中间处理

filter,map,flatMap,这几个操作跟Stream的处理类似,只是要注意flatMap处理必须手动指定返回类型为Optional<U>,而map会自动将返回值包装成Optional.举个栗子,我们有商品很订单的结构:

1. package model; 
2.  
3. import java.util.List; 
4.  
5. /** 
6.  * @auth gongxufan 
7.  * @Date 2017/10/23 
8.  **/ 
9. public class Goods { 
10.     private String goodsName; 
11.     private double price; 
12.     private List<Order> orderList; 
13.  
14.     public String getGoodsName() { 
15.         return goodsName; 
16.     } 
17.  
18.     public void setGoodsName(String goodsName) { 
19.         this.goodsName = goodsName; 
20.     } 
21.  
22.     public double getPrice() { 
23.         return price; 
24.     } 
25.  
26.     public void setPrice(double price) { 
27.         this.price = price; 
28.     } 
29.  
30.     public List<Order> getOrderList() { 
31.         return orderList; 
32.     } 
33.  
34.     public void setOrderList(List<Order> orderList) { 
35.         this.orderList = orderList; 
36.     } 
37. }  

1. package model; 
2.  
3. import java.time.LocalDateTime; 
4.  
5. /** 
6.  * @auth gongxufan 
7.  * @Date 2017/10/23 
8.  **/ 
9. public class Order { 
10.     private LocalDateTime createTime; 
11.     private LocalDateTime finishTime; 
12.     private String orderName; 
13.     private String orderUser; 
14.  
15.     public LocalDateTime getCreateTime() { 
16.         return createTime; 
17.     } 
18.  
19.     public void setCreateTime(LocalDateTime createTime) { 
20.         this.createTime = createTime; 
21.     } 
22.  
23.     public LocalDateTime getFinishTime() { 
24.         return finishTime; 
25.     } 
26.  
27.     public void setFinishTime(LocalDateTime finishTime) { 
28.         this.finishTime = finishTime; 
29.     } 
30.  
31.     public String getOrderName() { 
32.         return orderName; 
33.     } 
34.  
35.     public void setOrderName(String orderName) { 
36.         this.orderName = orderName; 
37.     } 
38.  
39.     public String getOrderUser() { 
40.         return orderUser; 
41.     } 
42.  
43.     public void setOrderUser(String orderUser) { 
44.         this.orderUser = orderUser; 
45.     } 
46. }  

现在我有一个goodsOptional

1. Optional<Goods> goodsOptional = Optional.ofNullable(new Goods()); 

现在我需要获取goodsOptional里边的orderList,应该这样你操作

1. goodsOptional.flatMap(g ->Optional.ofNullable(g.getOrderList())).orElse(Collections.emptyList()) 

flatMap里头返回的是Optional<List<Order>>,然后我们再使用orElse进行unwraap.因此faltMap可以解引用更深层次的的对象链.

5)检测Optional并执行动作

1. public void ifPresent(Consumer<? super T> consumer) { 
2.         if (value != null) 
3.             consumer.accept(value); 
4.     }  

这是一个终端操作,不像上边的可以进行链式操作.在Optional实例使用直接调用,如果value存在则会调用指定的消费方法.举个栗子:

1. Goods goods = new Goods(); 
2.  Optional<Goods> goodsOptional = Optional.ofNullable(goods); 
3.  List<Order> orderList = new ArrayList<>(); 
4.  goods.setOrderList(orderList); 
5.  goodsOptional.flatMap(g ->Optional.ofNullable(g.getOrderList())).ifPresent((v)-> System.out.println(v));  

至此该类的方法和使用介绍都差不多了,最后总结需要注意的地方:

1)Optional应该只用处理返回值,而不应该作为类的字段或者方法的参数.因为这样会造成额外的复杂度.

2)使用Option应该避免直接适应构造器和get,而应该使用isElse的系列方法避免频繁的非空判断

3)map和flatMap要注意区分使用场景  

原文发布时间为：2017-10-31

本文作者：吹着空调盖被子

本文来自云栖社区合作伙伴“51CTO”，了解相关信息可以关注。