Java8新特性-Optional

Love The Way You Lie 2021-09-21 16:50 469阅读 0赞

### 文章目录 ###

* * 简介
 * Optional源码分析和使用场景
 * * 属性和构造
 * 常用方法
 * * get()方法
 * isPresent()方法
 * ifPresent(Consumer<? super T> consumer)方法
 * filter()方法
 * map()方法
 * flatMap()方法
 * orElse()方法
 * orElseGet()方法
 * orElseThrow()方法
 * Optional实战
 * * 空判断
 * 断言
 * 使用误区
 * 总结

在学习Optional之前我们先来看下面的例子。在我们开发过程中，碰到的异常中**NullPointerException**必然是排行第一的。所以在平时编码中，我们会经常的判断**null**。

public void saveCity(City city) { 
        if (city != null) { 
            String cityName = city.getCityName();
            if (cityName != null) { 
                String code = cityDao.findCodeByName(cityName);
                city.setCode(code);
                cityDao.save(city);
            }
        }
    }

虽然上面代码变得更加安全，但是过多嵌套 if 语句降低代码整体可读性，提高复杂度。我们可以优化下代码

public void saveCity(City city) { 
        if (city == null) { 
            return;
        }
        String cityName = city.getCityName();
        if (cityName == null) { 
            return;
        }
        String code = cityDao.findCodeByName(cityName);
        city.setCode(code);
        cityDao.save(city);
    }

这样还可以，但我们通过Optional变的更简洁

public void saveCity(City city) { 
 // 就一行 city不为空返回 城市名称 否则直接返回空
 Optional<String> roleOpt = Optional.ofNullable(city).map(City::getCityName);
 // 如果容器中 不为空
 roleOpt.ifPresent(() -> { 
 String code = cityDao.findCodeByName(roleOpt.get());
 city.setCode(code);
 cityDao.save(city);
 });
 }

## 简介 ##

`java.util.Optional`类是Java8为了解决`null`值判断问题，借鉴google guava类库的`Optional`类而引入的一个同名`Optional`类。`java.util.Optional`类可以包含或不包含`null`值的容器对象。如果存在值，则`isPresent`方法将返回`true`，而`get`方法将返回该值。

除了`Optional`类之外，还扩展了一些常用类型的`Optional`对象，比如：`OptionalDouble`、`OptionalInt`、`OptionalLong`，用法基本上相似。

## Optional源码分析和使用场景 ##

`Optional`的源码比较简单，归根于它是一个简单的对象容器。下面会结合源码分析它的所有构造、属性、方法和对应的使用场景。

### 属性和构造 ###

`Optional`的属性和构造如下：

public final class Optional<T> { 
 
 // 这个是通用的代表NULL值的Optional实例
 private static final Optional<?> EMPTY = new Optional<>();
 
 // 泛型类型的对象实例
 private final T value;
 
 // 实例化Optional，注意是私有修饰符，value为NULL
 private Optional() { 
 this.value = null;
 }
 
 // 直接返回内部的EMPTY实例
 public static<T> Optional<T> empty() { 
 @SuppressWarnings("unchecked")
 Optional<T> t = (Optional<T>) EMPTY;
 return t;
 }
 
 // 通过value实例化Optional，如果value为NULL则抛出NPE
 private Optional(T value) { 
 this.value = Objects.requireNonNull(value);
 }
 
 // 通过value实例化Optional，如果value为NULL则抛出NPE，实际上就是使用Optional(T value)
 public static <T> Optional<T> of(T value) { 
 return new Optional<>(value);
 }
 
 // 如果value为NULL则返回EMPTY实例，否则调用Optional#of(value)
 public static <T> Optional<T> ofNullable(T value) { 
 return value == null ? empty() : of(value);
 }
 
 // 暂时省略其他代码
 }

可以看出，Optional类的两个构造方法都是private型的，因此类外部不能显示的使用new Optional()的方式来创建Optional对象，但是Optional类提供了三个静态方法empty()、of(T value)、ofNullable(T value)来创建Optinal对象，示例如下：

@Test
 public void testConstructor() { 
 // 1、创建一个包装对象值为空的Optional对象
 Optional<String> optStr = Optional.empty();
 // 2、创建包装对象值非空的Optional对象
 Optional<String> optStr1 = Optional.of("optional");
 // 3、创建包装对象值允许为空的Optional对象
 Optional<String> optStr2 = Optional.ofNullable(null);
 }

### 常用方法 ###

#### get()方法 ####

get()方法主要用于返回包装对象的实际值，但是如果包装对象值为null，会抛出NoSuchElementException异常

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

使用案例

@Test
 public void testGet() { 
 Optional<String> optional = Optional.of("thinkwon");
 Optional<String> optional1 = Optional.ofNullable(null);
 System.out.println(optional.get());
 System.out.println(optional1.get());
 }

输出结果

thinkwon
    
    
    java.util.NoSuchElementException: No value present

#### isPresent()方法 ####

isPresent()方法用于判断value是否存在，不为NULL则返回true，如果为NULL则返回false

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

使用案例

@Test
 public void testIsPresent() { 
 Optional<String> optional = Optional.of("thinkwon");
 Optional<String> optional1 = Optional.ofNullable(null);
 System.out.println(optional.isPresent());
 System.out.println(optional1.isPresent());
 }

输出结果

true
    false

**注意：下面例子的用法不但没有减少null的防御性检查，而且增加了Optional包装的过程，违背了Optional设计的初衷，因此开发中要避免这种糟糕的使用**

试想一下如果先用isPresent方法获得是否存在，然后决定是否调用get方法和之前的ifelse判断并无二致。

@Test
 public void testIsPresent1() { 
 Optional<String> optional = Optional.ofNullable(null);
 if (optional.isPresent()) { 
 System.out.println(optional.get());
 }
 }

#### ifPresent(Consumer<? super T> consumer)方法 ####

ifPresent()方法接受一个Consumer对象（消费函数），如果包装对象的值非空，运行Consumer对象的accept()方法

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

使用案例

@Test
 public void testIfPresent() { 
 Optional<String> optional = Optional.of("thinkwon");
 optional.ifPresent(s -> System.out.println("the String is " + s));
 }

输出结果

the String is thinkwon

#### filter()方法 ####

filter()方法接受参数为Predicate对象，用于对Optional对象进行过滤，如果符合Predicate的条件，返回Optional对象本身，否则返回一个空的Optional对象。

public Optional<T> filter(Predicate<? super T> predicate) { 
 Objects.requireNonNull(predicate);
 if (!isPresent()) { 
 return this;
 } else { 
 return predicate.test(value) ? this : empty();
 }
 }

使用案例

@Test
    public void testFilter() { 
        Optional.of("thinkwon").filter(s -> s.length() > 2)
                .ifPresent(s -> System.out.println("The length of String is greater than 2 and String is " + s));
    }

输出结果

The length of String is greater than 2 and String is thinkwon

#### map()方法 ####

map()方法的参数为Function（函数式接口）对象，map()方法将Optional中的包装对象用Function函数进行运算，并包装成新的Optional对象（包装对象的类型可能改变）

public Optional map(Function<? super T, ? extends U> mapper) { 
 Objects.requireNonNull(mapper);
 if (!isPresent()) { 
 return empty();
 } else { 
 return Optional.ofNullable(mapper.apply(value));
 }
 }

使用案例

@Test
 public void testMap() { 
 Optional<String> optional = Optional.of("thinkwon").map(s -> s.toUpperCase());
 System.out.println(optional.get());
 }

输出结果

THINKWON

#### flatMap()方法 ####

跟map()方法不同的是，入参Function函数的返回值类型为`Optional`类型，而不是U类型，这样flatMap()能将一个二维的Optional对象映射成一个一维的对象。

public Optional flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) { 
 Objects.requireNonNull(mapper);
 if (!isPresent()) { 
 return empty();
 } else { 
 @SuppressWarnings("unchecked")
 Optional r = (Optional) mapper.apply(value);
 return Objects.requireNonNull(r);
 }
 }

使用案例

@Test
 public void testFlatMap() { 
 Optional<String> optional = Optional.of("thinkwon").flatMap(s -> Optional.ofNullable(s.toUpperCase()));
 System.out.println(optional.get());
 }

输出结果

THINKWON

#### orElse()方法 ####

orElse()方法功能比较简单，即如果包装对象值非空，返回包装对象值，否则返回入参other的值（默认值）

public T orElse(T other) { 
        return value != null ? value : other;
    }

使用案例

@Test
    public void testOrElse() { 
        String unkown = (String) Optional.ofNullable(null).orElse("unkown");
        System.out.println(unkown);
    }

输出结果

unkown

#### orElseGet()方法 ####

orElseGet()方法与orElse()方法类似，区别在于orElseGet()方法的入参为一个Supplier对象，用Supplier对象的get()方法的返回值作为默认值

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

使用案例

@Test
    public void testOrElseGet() { 
        String unkown = (String) Optional.ofNullable(null).orElseGet(() -> "unkown");
        System.out.println(unkown);
    }

输出结果

unkown

#### orElseThrow()方法 ####

orElseThrow()方法其实与orElseGet()方法非常相似了，入参都是Supplier对象，只不过orElseThrow()的Supplier对象必须返回一个Throwable异常，并在orElseThrow()中将异常抛出，orElseThrow()方法适用于包装对象值为空时需要抛出特定异常的场景。

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

使用案例

@Test
    public void testOrElseThrow() { 
        Optional.ofNullable(null).orElseThrow(() -> new RuntimeException("unkown"));
    }

输出结果

java.lang.RuntimeException: unkown

## Optional实战 ##

下面展示一下`Optional`的一些常见的使用场景。

### 空判断 ###

空判断主要是用于不知道当前对象是否为`NULL`的时候，需要设置对象的属性。不使用`Optional`时候的代码如下：

if(null != order){ 
        order.setAmount(orderInfoVo.getAmount());
    }

使用`Optional`时候的代码如下：

Optional.ofNullable(order).ifPresent(o -> o.setAmount(orderInfoVo.getAmount()));

使用`Optional`实现空判断的好处是**只有一个属性设值的时候可以压缩代码为一行**，这样做的话，代码会相对简洁。

### 断言 ###

在维护一些老旧的系统的时候，很多情况下外部的传参没有做空判断，因此需要写一些断言代码如：

if (null == orderInfoVo.getAmount()){ 
        throw new IllegalArgumentException(String.format("%s订单的amount不能为NULL",orderInfoVo.getOrderId()));
    }
    if (StringUtils.isBlank(orderInfoVo.getAddress()){ 
        throw new IllegalArgumentException(String.format("%s订单的address不能为空",orderInfoVo.getOrderId()));
    }

使用`Optional`后的断言代码如下：

Optional.ofNullable(orderInfoVo.getAmount()).orElseThrow(()-> new IllegalArgumentException(String.format("%s订单的amount不能为NULL",orderInfoVo.getOrderId())));
    Optional.ofNullable(orderInfoVo.getAddress()).orElseThrow(()-> new IllegalArgumentException(String.format("%s订单的address不能为空",orderInfoVo.getOrderId())));

## 使用误区 ##

关于使用Optional的误区有以下：

*  正确的使用创建方法，不确定是否为null时尽量选择ofNullable方法；
 *  通过源代码会发现，它并没有实现java.io.Serializable接口，因此应避免在类属性中使用，防止意想不到的问题；
 *  避免直接调用Optional对象的get和isPresent方法，尽量多使用map()、filter()、orElse()等方法来发挥Optional的作用。

## 总结 ##

`Optional`本质是一个对象容器，它的特征如下：

1.  `Optional`作为一个容器承载对象，提供方法适配部分函数式接口，结合部分函数式接口提供方法实现`NULL`判断、过滤操作、安全取值、映射操作等等。
2.  `Optional`一般使用场景是用于方法返回值的包装，当然也可以作为临时变量从而享受函数式接口的便捷功能。
3.  `Optional`只是一个简化操作的工具，可以解决多层嵌套代码的节点空判断问题（例如简化箭头型代码）。
4.  `Optional`并非银弹。

这里提到箭头型代码，下面尝试用常规方法和`Optional`分别解决：

// 假设VO有多个层级，每个层级都不知道父节点是否为NULL，如下
    // - OrderInfoVo
    // - UserInfoVo
    // - AddressInfoVo
    // - address(属性)
    // 假设我要为address属性赋值，那么就会产生箭头型代码。
    
    
    // 常规方法
    String address = "xxx";
    OrderInfoVo o = ...;
    if(null != o){ 
        UserInfoVo uiv = o.getUserInfoVo();
        if (null != uiv){ 
            AddressInfoVo aiv = uiv.getAddressInfoVo();
            if (null != aiv){ 
                aiv.setAddress(address);
            }
        }
    }
    
    // 使用Optional
    String address = "xxx";
    OrderInfoVo o = null;
    Optional.ofNullable(o)
            .map(OrderInfoVo::getUserInfoVo)
            .map(UserInfoVo::getAddressInfoVo)
            .ifPresent(a -> a.setAddress(address));

使用`Optional`解决箭头型代码，通过映射操作`map()`能减少大量的`if`和`NULL`判断分支，使得代码更加简洁。

有些开发者提议把`DAO`方法的返回值类型定义为`Optional`，笔者对此持中立态度，原因是：

1.  `Optional`是JDK1.8引入，低版本的JDK并不能使用，不是所有的系统都能平滑迁移到JDK1.8+。
2.  并不是所有人都热衷于函数式编程，因为它带来了便捷的同时转变了代码的阅读逻辑（有些人甚至会认为降低了代码的可读性）。