Java8新特性-Optional

qq_39093474

已于 2023-04-23 14:03:23 修改

阅读量214

点赞数

分类专栏： java基础文章标签： java jvm 前端

于 2023-04-22 23:06:25 首次发布

java基础专栏收录该内容

23 篇文章 0 订阅

订阅专栏

文章目录

简介
Optional源码分析和使用场景
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> cityNameOpt = Optional.ofNullable(city).map(City::getCityName);
    // 如果容器中 不为空
    cityNameOpt.ifPresent(n -> {
        String code = cityDao.findCodeByName(n);
        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<T>类（java.util.Optional）是一个容器类，代表一个值存在或不存在，原来用null值表示一个值不存在，现在用Optional可以更好的表达这个概念，并且可以避免空指针异常。

常用方法：

方法	用途
Optional of(T value)	创建一个Optional 实例
Optional empty()	创建一个空的Optional 实例
Optional ofNullable(T value)	若value不为null，则创建一个Optional 实例，否则创建一个空实例
boolean isPresent()	判断是否包含值，如果存在值，则isPresent方法将返回true
ifPresent(Consumer<? super T> consumer)	如果包装对象的值非空，运行Consumer对象的accept()方法
Optional filter(Predicate<? super T> predicate)	如果符合Predicate的条件，返回Optional对象本身，否则返回一个空的Optional对象。
Optional map(Function<? super T, ? extends U> mapper)	如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty()
Optional flatMap(Function<? super T, Optional> mapper)	与map类似，要求返回值必须是Optional
T orElse(T other)	如果调用对象包含值，则返回该值，否则返回ohther
T orElseGet(Supplier<? extends T> other)	如果调用对象包含值，则返回该值，否则返回ohther 获取的值

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 <U> Optional<U> 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>类型，而不是U类型，这样flatMap()能将一个二维的Optional对象映射成一个一维的对象。

public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent()) {
        return empty();
    } else {
        @SuppressWarnings("unchecked")
        Optional<U> r = (Optional<U>) 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语法只是在 JDK1.8版本后才开始引入，那还在用 JDK1.8版本之前的老项目怎么办呢？

没关系！

Google大名鼎鼎的 Guava库中早就提供了 Optional接口来帮助优雅地处理 null对象问题，其本质也是在可能为 null的对象上做了一层封装，使用起来和JDK本身提供的 Optional接口没有太大区别。

你只需要在你的项目里引入 Google的 Guava库：

<dependency>
	<groupId>com.google.guava</groupId>
	<artifactId>guava</artifactId>
</dependency>

即可享受到和 Java8版本开始提供的 Optional一样的待遇！

使用误区

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

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

总结

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

Optional作为一个容器承载对象，提供方法适配部分函数式接口，结合部分函数式接口提供方法实现NULL判断、过滤操作、安全取值、映射操作等等。
Optional一般使用场景是用于方法返回值的包装，当然也可以作为临时变量从而享受函数式接口的便捷功能。
Optional只是一个简化操作的工具，可以解决多层嵌套代码的节点空判断问题（例如简化箭头型代码）。
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，笔者对此持中立态度，原因是：

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

qq_39093474

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java8新特性-Optional

类是Java8为了解决null值判断问题，借鉴类库的Optional类而引入的一个同名Optional类。类可以包含或不包含null值的容器对象。如果存在值，则isPresent方法将返回true，而get方法将返回该值。除了Optional类之外，还扩展了一些常用类型的Optional，用法基本上相似。类（）是一个容器类，代表一个值存在或不存在，原来用null值表示一个值不存在，现在用Optional可以更好的表达这个概念，并且可以避免空指针异常。方法用途创建一个Optional 实例。
复制链接

扫一扫