Java8的Optional简介

于 2024-09-17 11:50:15 发布
阅读量1.1k 收藏 26
点赞数 22
分类专栏： Java 文章标签： java optional
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/duke_ding2/article/details/142310643
版权

文章目录

注：本文主要参考了《Java 8实战》这本书。

在这里插入图片描述

环境

  • Ubuntu 22.04
  • jdk-17.0.3.1 （兼容Java 8）

背景

现有 Insurance 、 Car 、 Person 类，定义如下：

  • Insurance ：
public class Insurance {
    private String name;

    public String getName() {
        return name;
    }
    ......
}
  • Car ：
public class Car {
    private Insurance insurance;

    public Insurance getInsurance() {
        return insurance;
    }
    ......
}
  • Person ：
public class Person {
    private Car car;

    public Car getCar() {
        return car;
    }
    ......
}

现在需要获取某个Person的Car的Insurance名字。

方法1：直接获取

最简单粗暴的写法，就是：

        String name = person.getCar().getInsurance().getName();

注：像这样 a.b.c 的调用方式，貌似违反了迪米特法则。

然而，我们知道，在Java里，如果操作一个空对象，则会抛出异常。

最简单的例子：

        Person person = null;
        person.getCar();

此处 person 是空对象，所以调用 person.getCar() 方法时，会抛出 NullPointerException 异常：

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "Person.getCar()" because "person" is null
	at Test0917.main(Test0917.java:8)

所以，这种方法显然是不可取的。

方法2：防御式检查

为了避免NPE，我们必须采取“防御式编程”，也就是说，在操作对象时，先要确保它不是空对象。

        String name = null;
        if (person != null) {
            Car car = person.getCar();
            if (car != null) {
                Insurance insurance = car.getInsurance();
                if (insurance != null) {
                    name = insurance.getName();
                }
            }
        }

防御式检查可以避免NPE，然而代价是代码变得臃肿而且难以理解和维护。原先只有1行代码，现在变成了10行。

如果使用三元运算符 ? :，固然可以简化为一行代码：

        String name = (person == null)
                ? null
                : ((person.getCar() == null)
                        ? null
                        : ((person.getCar().getInsurance() == null)
                                ? null
                                : (person.getCar().getInsurance().getName())));

但是这行代码实在是太令人费解了，同时非常难以维护。

方法3：Java 8的Optional

概述

方法1很简单，但有漏洞，方法2弥补了漏洞，但带来了复杂度。那如何才能兼顾简单与安全呢？

Java 8引入了Optional类，这是一个封装“Optional值”的类。顾名思义，既然是optional，其封装的值可能存在，也可能不存在。

举个例子来说，一个 Optional<Car> 对象，可能封装了一个非空的 Car 对象，也可能封装了一个 null 对象。

现在简单看一下创建Optional的语法：

  • 创建一个空的Optional对象：
        Optional<Car> car1 = Optional.empty();
  • 创建一个非空的Optional对象：
        Optional<Car> car2 = Optional.of(car); // car不能为null

其中， car 是一个Car对象，而且必须是非空的，否则，这一步会直接抛出NPE。

  • 如果想创建一个可接受空值的Optional对象：
        Optional<Car> car3 = Optional.ofNullable(car); // car可以为null

从Optional对象获取其封装对象：

  • get() ：
        Optional<Car> car4;
        ......
        Car car = car4.get(); // 获取封装的Car对象，若其为空，则抛出NoSuchElementException
  • orElse() ：
        Car car = car4.orElse(new Car()); // 获取封装的Car对象，若其为空，则返回指定值

map()

看到这里，你可能还是一头雾水，到底Optional能给我们带来什么好处？

Optional的神奇之处在于，它和流（Stream）的用法非常相似，可以做 map() 、 filter() 等操作。事实上，它就相当于只包含0个或者1个对象的流。

在方法1中：

        String name = person.getCar().getInsurance().getName();

可见，代码逻辑是依次获取Car、Insurance、Name。

通过Optional，可以把它转换为如下操作：

        Optional<Person> optPerson = Optional.ofNullable(person);

        String name = optPerson.map(Person::getCar)
                .map(Car::getInsurance)
                .map(Insurance::getName)
                .orElse("Unknown");

本例中， map() 操作把Optional所持有的对象做了映射，比如本来是持有Person（ Optional<Person> ），变成持有Car（ Optional<Car> ），再变成持有String（ Optional<String> ），最终获取String对象。

如果持有对象不为空，则对其做map操作，若持有对象为空，则不做处理。这就大大简化了代码，提高了可读性和可维护性。

测试

完整的测试如下：

  • 测试1：Person，Car，Insurance都不为空：
        Insurance insurance1 = new Insurance("ABC");
        Car car1 = new Car(insurance1);
        Person person1 = new Person(car1);
        Optional<Person> optPerson1 = Optional.ofNullable(person1);
        System.out.println(optPerson1.map(Person::getCar));
        System.out.println(optPerson1.map(Person::getCar).map(Car::getInsurance));
        System.out.println(optPerson1.map(Person::getCar).map(Car::getInsurance).map(Insurance::getName));
        System.out.println(optPerson1.map(Person::getCar).map(Car::getInsurance).map(Insurance::getName).orElse("Unknown"));

运行结果如下：

Optional[Car{insurance=Insurance{name='ABC'}}]
Optional[Insurance{name='ABC'}]
Optional[ABC]
ABC
  • 测试2：Person和Car不为空，Insurance为空：
        Car car2 = new Car(null);
        Person person2 = new Person(car2);
        Optional<Person> optPerson2 = Optional.ofNullable(person2);
        System.out.println(optPerson2.map(Person::getCar));
        System.out.println(optPerson2.map(Person::getCar).map(Car::getInsurance));
        System.out.println(optPerson2.map(Person::getCar).map(Car::getInsurance).map(Insurance::getName));
        System.out.println(optPerson2.map(Person::getCar).map(Car::getInsurance).map(Insurance::getName).orElse("Unknown"));

运行结果如下：

Optional[Car{insurance=null}]
Optional.empty
Optional.empty
Unknown
  • 测试3：Person不为空，Car和Insurance为空：
        Person person3 = new Person(null);
        Optional<Person> optPerson3 = Optional.ofNullable(person3);
        System.out.println(optPerson3.map(Person::getCar));
        System.out.println(optPerson3.map(Person::getCar).map(Car::getInsurance));
        System.out.println(optPerson3.map(Person::getCar).map(Car::getInsurance).map(Insurance::getName));
        System.out.println(optPerson3.map(Person::getCar).map(Car::getInsurance).map(Insurance::getName).orElse("Unknown"));

运行结果如下：

Optional.empty
Optional.empty
Optional.empty
Unknown
  • 测试4：Person，Car，Insurance都为空：
        Optional<Person> optPerson4 = Optional.ofNullable(null);
        System.out.println(optPerson4.map(Person::getCar));
        System.out.println(optPerson4.map(Person::getCar).map(Car::getInsurance));
        System.out.println(optPerson4.map(Person::getCar).map(Car::getInsurance).map(Insurance::getName));
        System.out.println(optPerson4.map(Person::getCar).map(Car::getInsurance).map(Insurance::getName).orElse("Unknown"));

运行结果如下：

Optional.empty
Optional.empty
Optional.empty
Unknown

可见，在任何情况下，都能得到预期的结果，不会报错。

flatMap()

既然Person不一定拥有Car，Car也不一定拥有Insurance，所以应该都是optional的。

假设修改类如下：

  • Car ：
public class Car {
    private Insurance insurance;

    public Optional<Insurance> getInsurance() {
        return Optional.ofNullable(insurance);
    }
    ......
}
  • Person ：
public class Person {
    private Car car;

    public Optional<Car> getCar() {
        return Optional.ofNullable(car);
    }
    ......
}

注意：要确保 getXxx() 返回的Optional对象本身不要为空，否则，就又得加上判断逻辑了。

相应的， map() 操作需要转换为 flatMap() ：

        Optional<Person> optPerson = Optional.ofNullable(person);

        String name = optPerson.flatMap(Person::getCar)
                .flatMap(Car::getInsurance)
                .map(Insurance::getName)
                .orElse("Unknown");

注意：这里之所以使用 flatMap() ，是因为 Person::getCar 返回的是 Optional<Car> ，需要用 flatMap() 将其扁平化（去掉中间层的Optional）。

注意：要确保 getXxx() 返回的Optional对象本身不要为空，否则，在调用 flatMap() 时会抛出NPE。

测试

下面是完整的测试：

  • 测试1：Person，Car，Insurance都不为空：
        Insurance insurance1 = new Insurance("ABC");
        Car car1 = new Car(insurance1);
        Person person1 = new Person(car1);
        Optional<Person> optPerson1 = Optional.ofNullable(person1);
        System.out.println(optPerson1.flatMap(Person::getCar));
        System.out.println(optPerson1.flatMap(Person::getCar).flatMap(Car::getInsurance));
        System.out.println(optPerson1.flatMap(Person::getCar).flatMap(Car::getInsurance).map(Insurance::getName));
        System.out.println(optPerson1.flatMap(Person::getCar).flatMap(Car::getInsurance).map(Insurance::getName).orElse("Unknown"));

运行结果如下：

Optional[Car{insurance=Insurance{name='ABC'}}]
Optional[Insurance{name='ABC'}]
Optional[ABC]
ABC
  • 测试2：Person和Car不为空，Insurance为空：
        Car car2 = new Car(null);
        Person person2 = new Person(car2);
        Optional<Person> optPerson2 = Optional.ofNullable(person2);
        System.out.println(optPerson2.flatMap(Person::getCar));
        System.out.println(optPerson2.flatMap(Person::getCar).flatMap(Car::getInsurance));
        System.out.println(optPerson2.flatMap(Person::getCar).flatMap(Car::getInsurance).map(Insurance::getName));
        System.out.println(optPerson2.flatMap(Person::getCar).flatMap(Car::getInsurance).map(Insurance::getName).orElse("Unknown"));

运行结果如下：

Optional[Car{insurance=null}]
Optional.empty
Optional.empty
Unknown
  • 测试3：Person不为空，Car和Insurance为空：
        Person person3 = new Person(null);
        Optional<Person> optPerson3 = Optional.ofNullable(person3);
        System.out.println(optPerson3.flatMap(Person::getCar));
        System.out.println(optPerson3.flatMap(Person::getCar).flatMap(Car::getInsurance));
        System.out.println(optPerson3.flatMap(Person::getCar).flatMap(Car::getInsurance).map(Insurance::getName));
        System.out.println(optPerson3.flatMap(Person::getCar).flatMap(Car::getInsurance).map(Insurance::getName).orElse("Unknown"));

运行结果如下：

Optional.empty
Optional.empty
Optional.empty
Unknown
  • 测试4：Person，Car，Insurance都为空：
        Optional<Person> optPerson4 = Optional.ofNullable(null);
        System.out.println(optPerson4.flatMap(Person::getCar));
        System.out.println(optPerson4.flatMap(Person::getCar).flatMap(Car::getInsurance));
        System.out.println(optPerson4.flatMap(Person::getCar).flatMap(Car::getInsurance).map(Insurance::getName));
        System.out.println(optPerson4.flatMap(Person::getCar).flatMap(Car::getInsurance).map(Insurance::getName).orElse("Unknown"));

运行结果如下：

Optional.empty
Optional.empty
Optional.empty
Unknown

总结

Optional 类帮助我们处理可能存在的null值。它的用法类似于流（Stream），简单明了，可以精简代码，提高代码可读性和可维护性。

Optional的常用方法如下：

方法描述
empty()返回一个空的Optional实例
filter()类似流的filter
flatMap()类似流的flatMap
get()获取封装的对象，若其为空，则抛出NoSuchElementException
ifPresent()如果值存在，则运行传入的Consumer
isPresent()值是否存在
map()类似流的map
of()返回封装指定值的Optional对象，若指定值为null，则抛出NPE
ofNullable()同of()，但允许null值
orElse()获取封装的对象，若其为空，则返回指定值
orElseGet()获取封装的对象，若其为空，则运行传入的Supplier并返回其结果
orElseThrow()获取封装的对象，若其为空，则运行传入的Supplier并抛出其生成的异常

参考

  • https://livebook.manning.com/book/java-8-in-action/
蓝黑2020
关注
专栏目录
Java8新特性-Optional
qdwd888的博客
04-28 519
使用案例 @Test public void testIsPresent() { Optional optional = Optional.of(“thinkwon”); Optional optional1 = Optional.ofNullable(null); System.out.println(optional.isPresent()); System.out.println(optional1.isPresent()); } 输出结果 true false 注意：下面例子的用法不但没有减少nul
Java8 Optional原理及用法解析
09-07
Java 8 中的 `Optional` 类是一个非常重要的特性，它为开发者提供了一种优雅的方式来处理可能为 `null` 的值，从而避免空指针异常（`NullPointerException`）。`Optional` 类的设计灵感来源于 Google 的 Guava 库，...
Java8 之 Optional 详解
流华追梦的专栏
11-29 3184
关于使用Optional的误区有以下：1. 正确的使用创建方法，不确定是否为 null 时尽量选择 ofNullable 方法；2. 通过源代码会发现，它并没有实现 java.io.Serializable 接口，因此应避免在类属性中使用，防止意想不到的问题；3. 避免直接调用 Optional 对象的 get() 和 isPresent() 方法，尽量多使用 map()、filter()、orElse()等方法来发挥 Optional 的作用。
Java 8中Optional类
最新发布
welcome
08-29 317
Optional是Java 8引入的一个容器类，用来表示可能存在也可能不存在的值。它为解决空指针异常提供了一种更优雅的解决方案。与直接使用null不同，Optional明确地表示一个值的存在或缺失，避免了因意外的null值引发的。Optional本质上是一个容器对象，它可能包含一个非空值，也可能为空。当值存在时，Optional会持有该值；当值不存在时，Optional会被认为是“空”的，这种明确的表示方式使得代码更易于理解和维护。Optional方法返回值：当方法的返回值可能为空时，可以返回一个。
Java 8 Optional 类 学习
东子的博客 细节决定成败，点滴铸就辉煌。
03-15 925
1. Optional类的简介Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。 Optional 类的引入很好的解决空指针异常。2.类声明以下是一个 java.util.
java8的Optional 详解
热门推荐
m0_58680865的博客
04-30 1万+
1、Optional 介绍 传统的写代码方式经常会遇到NullPointerException，这就需要我们在代码中经常判空。而判空的写法又会显得很累赘，这里就可以用到Optional来简化代码。 Optional是在java.util包下的一个用于代替null的一个工具类。 import java.util.Optional; Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。 Optional 类是一个可以为n
Java8 Optional详解
qq_37436172的博客
06-19 459
根据Oracle文档，Optional是一个容器对象，可以包含也可以不包含非null值。Optional在Java 8中引入，目的是解决 NullPointerExceptions的问题。本质上，Optional是一个包装器类，其中包含对其他对象的引用。在这种情况下，对象只是指向内存位置的指针，并且也可以指向任何内容。从其它角度看，Optional提供一种类型级解决方案来表示可选值而不是空引用。 在Optional之前 在Java 8之前，程序员将返回null而不是Optional。这种方法有一些缺点。一
使用Java8中Optional机制的正确姿势
08-28
Java 8 中引入的 `Optional` 类是一种设计模式，旨在帮助开发者更好地处理 `null` 值，从而减少 `NullPointerException` 的出现。`Optional` 并不是为了消除所有的空值检查，而是为了改进代码的清晰性和可读性，避免...
Java8Optional机制的正确使用方式共6页.pdf
10-29
Java 8 Optional 是一个强大的工具，它被引入来帮助开发者避免空指针异常（NullPointerException）。这个特性是为了提高代码的清晰性和可读性，通过显式地处理缺失值，使得空值处理更加优雅和安全。本篇文章将深入...
Java如何使用Optional与Stream取代if判空逻辑（JDK8以上）
08-25
Java 8引入了两个强大的工具，Optional 和 Stream，它们极大地改善了处理可能为空的对象的方式，减少了if语句的使用，使代码更加简洁、易读。本文将深入探讨如何使用这两个特性来取代传统的if判空逻辑。 首先，让...
java中option_Java8 如何正确使用 Optiona
weixin_28804631的博客
02-13 5731
原标题：Java8 如何正确使用 OptionaOptional是Java8提供的为了解决null安全问题的一个API。善用Optional可以使我们代码中很多繁琐、丑陋的设计变得十分优雅。这篇文章是建立在你对Optional的用法有一定了解的基础上的，如果你还不太了解Optional，可以先去看看相关教程，或者查阅Java文档。使用Optional，我们就可以把下面这样的代码进行改写。 不过，千...
Java8 Optional
ZHUSHANGLIN的博客
02-22 257
Optional和Stream虽然都是Java8的新特性，但据我观察Optional的使用频率远低于Stream，究其原因是大家对它有误解。很多人以为Optional是用来“消除”空指针的，所以当他们发现即便使用了Optional还会抛异常时，感到非常地失望，甚至是愤怒。比如当value确实为null时，直接调用Optional#get()会抛出NoSuchElementException： // Optional#get()底层源码，当value为null时抛出NoSuchElementExcepti
java8-Optional
AmiVincent的博客
07-24 601
Java8新特性Optional
java optional详解_java8 Optional类详解
weixin_34025386的博客
02-12 452
Optionaljava8中引入一个新的类java.util.Optional。这是一个包装引用类型的一个类。java8之前调用方法的时候当我们不知道返回值是否可能为null的时候，我们要对每个结果使用前进行null检查，如果不慎对null引用进行调用就会抛出NullPointerException异常。现在我们可以通过Optional.empty()返回一个空的Optional对象，它返回一个特...
Java8的Options介绍
努力奋斗
04-27 2344
Java8引入了一个名为 Options 的新类，它是一个容器，可以保存单个值或根本不保存任何值。Optional目的是提供一种更优雅的方式来处理 null 值，这通常会导NullPointerException。在这篇博客文章中，我们将探索如何在 Java8中使用 Options，并提供一个演示来演示它的用法。
java中flypaper怎么使用_Java8 Optional的详细使用教程
weixin_39871649的博客
02-24 130
Optional介绍Optional是Jdk1.8提供的一个新类，希望可以通过该类的引入解决令人烦躁的null判断问题，非常好用。个人理解：这个类是一个包装类，将要操作的java bean封装到该类的对象里面，同时将一些常用的判断逻辑封装为成员方法，结合lambda语法，实现比较优雅的链式调用。现在对Optional的API使用做一个简单的说明。API介绍Optional的所有的方法如下图所示，这...
Java8新特性之Optional
学习不止境的博客
07-29 448
以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到GoogleGuava的启发，Optional类已经成为Java8类库的一部分。Optional实际上是个容器它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。假设我们有两个类，他们的UML类图如下图所示在这种情况下，有如下代码if(user!=null){...
Java8新特性之——Optional类
dongdong199033的博客
04-09 2447
Optional类是Java 8中引入的一个用于处理null值的容器类。它封装了某个类型的值，这个值可以是null，也可以是非null，通过它可以更优雅和简洁地处理包含null值的对象。Optional类的官方描述：翻译过来就是：一个可能包含null值的容器对象。如果值存在，isPresent()方法将会返回true，get()方法将会返回该值。
【Java 新特性系列】Java 8 Optional 类完全指南
栗筝i的博客
06-08 3738
Java 8 引入的Optional类，是一个可以包含或不包含非空值的容器对象。它的目的是为了提供一种更优雅的方式来处理可能为null的值，从而避免直接使用null值可能引发的。使用Optional类可以显著改善代码的可读性和健壮性。防止：使用Optional可以明确地要求用户在使用变量之前处理null情况；增强代码可读性：通过使用Optional的方法，代码的可读性和意图更加明确；Optional类型在 Java 8 的流（Stream）操作中被广泛使用，提供了更复杂的条件查询和变换功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值