Java8新特性（案例分析）-- Optional接口妙用：避免嵌套if

一、of()、ofNullable()区别

Optional是一个容器，可以包含一个非null的值，也可以包含一个null值。当value存在的时候，调用isPresent()方法将会返回true。通过get()方法，则可得到被Optional容器包裹的值对象。

使用Optional时，通常会以Optional.of()、Optional.ofNullable()开始，那么二者有何区别？源码如下，可以看出，of()不可以传入null对象，而ofNullable()可以包裹null对象。

    public static <T> Optional<T> of(T value) {
            return new Optional<>(value);
    }

    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

二、Optional妙用

Optional接口无疑为我们提供了一个避免NPE问题的好方法，利用Optional提供的一些方法，我们可以避免显示的判空操作。

--> 当代码中存在判空操作，或者嵌套if的时候，可以考虑使用Optional接口。

（一）Optional用于一层if判空

考虑一个场景，需要依据每场跳绳比赛的跳绳次数来进行一些计算，如

Map<Integer, Map<Integer, Integer>>
Key：跳绳比赛场次id
value：当前场次的跳绳次数情况。value的Map中，key为跳绳个数，value为跳绳个数对应的人数。

在微服务架构中，对于Map<Integer, Map<Integer, Integer>>这样的结构，通常是从下游获取的数据，在系统中通常是不易理解的，会增加理解成本。而在DDD领域中，通常需要将它转化为领域内的value object。所以，需要将Map<Integer, Map<Integer, Integer>>转化为易于理解和维护的结构，如Map<Integer, List<RopeSkippingValue>>，其具体含义为

Map<Integer, List<RopeSkippingValue>>：每场跳绳比赛中，有多少人的跳绳个数是相同的。

RopeSkippingValue的具体定义如下：

class RopeSkippingValue{
    // 跳绳个数
    private Integer skippingTimes;
    // 跳绳个数对应的人数
    private Integer peopleNum;
}

如果不采用Optional和Stream操作，那么从Map<Integer, Map<Integer, Integer>>到Map<Integer, List<RopeSkippingValue>>的转化的代码，将是相对较low的（大家可以尝试下）。对于中大厂而言，不优雅的代码（通常所说的丑代码）是不可接受的。

采用Optional+Stream才做，则可写成以下样式：

Optional.ofNullable(ropeSkippingInfoMap)
        .orElse(Collections.emptyMap())
        .entrySet()
        .stream()
        .collect(Collectors.toMap(Entry::getKey,
                  ropeSkippingEntry -> ropeSkippingEntry.getValue()
                                                        .keySet()
                                                        .stream()
                                                        .map(boughtTimes ->                                                                                  
            RopeSkippingValueFactory.createRopeSkippingTimesValue(skippingTimes, 
                ropeSkippingEntry.getValue()                                                                                                                                                                
                                 .get(skippingTimes)))
                                                  .collect(Collectors.toList()))));

（二）Optional用于多层、嵌套if判空

比如，对于电商系统，往往需要记录用户信息，简化的结果如下：

class UserInfo{
    private Long userId;
    private String name;
    private Address address;
}

class Address{
    private Province province;
    private City city;
    private County county;
}

class City{
    private Long cityId;
    private String cityName;
    /**
        ...
    */
}

根据上面的结构，想要获取用户所在城市，不采用Optional，则代码如下：

if(user !=null){
    Address address = user.getAddress();
    if(address!=null){
        City city = address.getCity();
        if(city != null){
            return city.getName();
        }
    }
}

// 或者写法如下
if(user!=null && user.getAddress()!=null && user.getAddress().getCity()!=null){
    return user.getAddress().getCity().getName();
}

不管是上面的哪种写法，在实际工作中，都是不可取的。如果采用Optional来处理，则代码如下：

Optional.ofNullable(user)
        .map(UserInfo::getAddress)
        .map(Address::getCity)
        .map(City::getName)
        .orElse(null);

对比两段代码可以看出，采用Optional可以很好的解决if以及嵌套判空的问题。