理解、接受和利用 Java 中的 Optional

痛定思痛。 2023-09-27 11:00 69阅读 0赞

#### **概述** ####

Java 8 引入该语言的最有趣的特性之一是新的[Optional类][Optional]。这个类旨在解决的主要问题是臭名昭著的*NullPointerException* ，每个[Java][]程序员都非常清楚。

本质上，这是一个包含可选值的包装类，这意味着它可以包含一个对象，也可以简单地为空。

Optional 伴随着**向 Java 函数式编程迈进的一大步** ，旨在帮助实现该范式，但也绝对不在此范围内。

让我们从一个简单的用例开始。在 Java 8 之前，任何涉及访问对象的方法或属性的操作都可能导致*NullPointerException*：

String isocode = user.getAddress().getCountry().getIsocode().toUpperCase();

如果我们想确保在这个简短的示例中不会遇到异常，我们需要在访问每个值之前对其进行显式检查：

if (user != null) {
        Address address = user.getAddress();
        if (address != null) {
            Country country = address.getCountry();
            if (country != null) {
                String isocode = country.getIsocode();
                if (isocode != null) {
                    isocode = isocode.toUpperCase();
                }
            }
        }
    }

如您所见，这很容易变得繁琐且难以维护。

为了简化这个过程，让我们看一下如何使用*Optional*类，从创建和验证实例，到使用它提供的不同方法并将其与返回相同类型的其他方法组合，后者是*可选*谎言的真正力量。

#### **创建*可选*实例** ####

重申一下，这种类型的对象可以包含一个值或为空。您可以使用具有相同名称的方法创建一个空的 Optional：

@Test(expected = NoSuchElementException.class)
    public void whenCreateEmptyOptional_thenNull() {
        Optional<User> emptyOpt = Optional.empty();
        emptyOpt.get();
    }

毫不奇怪，尝试访问*emptyOpt*变量的值会导致*NoSuchElementException*。

要创建一个可以包含值的*Optional对象，您可以使用**of()*和 ofNullable() 方法。两者之间的区别在于，如果将*null*值作为参数传递给*of()*方法，它将抛出*NullPointerException ：*

@Test(expected = NullPointerException.class)
    public void whenCreateOfEmptyOptional_thenNullPointerException() {
        Optional<User> opt = Optional.of(user);
    }

如您所见，我们并没有完全摆脱*NullPointerException*。因此，只有在确定对象不为*null时才应使用**of()*。

如果对象既可以是*null*也可以不是*null*，那么您应该选择*ofNullable()*方法：

Optional<User> opt = Optional.ofNullable(user);

**访问*可选*对象的值**

*在Optional*实例中检索实际对象的一种方法是使用*get()*方法：

@Test
    public void whenCreateOfNullableOptional_thenOk() {
        String name = "John";
        Optional<String> opt = Optional.ofNullable(name);
        
        assertEquals("John", opt.get());
    }

*但是，如您之前所见，如果值为null*，此方法将引发异常。为避免此异常，您可以选择首先验证值是否存在：

@Test
    public void whenCheckIfPresent_thenOk() {
        User user = new User("john@gmail.com", "1234");
        Optional<User> opt = Optional.ofNullable(user);
        assertTrue(opt.isPresent());
    
        assertEquals(user.getEmail(), opt.get().getEmail());
    }

检查值是否存在的另一个选项是*ifPresent()*方法。除了执行检查之外，此方法还接受一个*Consumer*参数并在对象不为空时执行 lambda 表达式：

opt.ifPresent( u -> assertEquals(user.getEmail(), u.getEmail()));

在此示例中，仅当用户对象不为空时才执行断言。

接下来，让我们看看可以提供空值替代方案的方法。

**返回默认值**

*Optional*类提供了用于返回对象值的API，如果对象为空，则返回默认值。

您可以为此目的使用的第一个方法是*orElse()*，它以一种非常直接的方式工作：如果存在则返回值，如果不存在则返回接收的参数：

@Test
    public void whenEmptyValue_thenReturnDefault() {
        User user = null;
        User user2 = new User("anna@gmail.com", "1234");
        User result = Optional.ofNullable(user).orElse(user2);
    
        assertEquals(user2.getEmail(), result.getEmail());
    }

此处，*用户*对象为空，因此将*user2*作为默认值返回。

如果对象的初始值不为 null，则忽略默认值：

@Test
    public void whenValueNotNull_thenIgnoreDefault() {
        User user = new User("john@gmail.com","1234");
        User user2 = new User("anna@gmail.com", "1234");
        User result = Optional.ofNullable(user).orElse(user2);
    
        assertEquals("john@gmail.com", result.getEmail());
    }

同一类别中的第二个 API 是*orElseGet()* \- 它的行为方式略有不同。在这种情况下，如果存在，则该方法返回值，如果不存在，则执行它作为参数接收的*Supplier功能接口，并返回该执行的结果：*

User result = Optional.ofNullable(user).orElseGet( () -> user2);

***orElse()*和*orElseGet()*的区别**

乍一看，这两种方法似乎具有相同的效果。但是，情况并非如此。让我们创建一些示例来突出两者之间的相似性和行为差异。

首先，让我们看看当对象为空时它们的行为：

@Test
    public void givenEmptyValue_whenCompare_thenOk() {
        User user = null
        logger.debug("Using orElse");
        User result = Optional.ofNullable(user).orElse(createNewUser());
        logger.debug("Using orElseGet");
        User result2 = Optional.ofNullable(user).orElseGet(() -> createNewUser());
    }
    
    private User createNewUser() {
        logger.debug("Creating New User");
        return new User("extra@gmail.com", "1234");
    }

在上面的代码中，这两个方法都调用了*createNewUser()*方法，该方法记录了一条消息并返回一个*User*对象。

这段代码的输出是：

Using orElse
    Creating New User
    Using orElseGet
    Creating New User

因此，当对象为空并返回默认对象时，行为没有区别。

接下来，我们来看一个类似的例子，其中*Optional*不为空：

@Test
    public void givenPresentValue_whenCompare_thenOk() {
        User user = new User("john@gmail.com", "1234");
        logger.info("Using orElse");
        User result = Optional.ofNullable(user).orElse(createNewUser());
        logger.info("Using orElseGet");
        User result2 = Optional.ofNullable(user).orElseGet(() -> createNewUser());
    }

这次的输出是：

Using orElse
    Creating New User
    Using orElseGet

在这里，两个*Optional*对象都包含方法将返回的非空值。但是，*orElse()*方法仍将创建默认的*User*对象。**相比之下，*orElseGet()*方法将不再创建*User*对象。**

如果执行的操作涉及更密集的调用，例如 Web 服务调用或数据库查询，**这种差异可能会对****[性能产生重大影响。][Link 1]**

**返回异常**

在*orElse()*和*orElseGet()*方法旁边，Optional 还定义了一个*orElseThrow()* API - 如果对象为空，它不会返回替代值，而是抛出异常：

@Test(expected = IllegalArgumentException.class)
    public void whenThrowException_thenOk() {
        User result = Optional.ofNullable(user)
          .orElseThrow( () -> new IllegalArgumentException());
    }

在这里，如果*用户*值为 null，则会引发*IllegalArgumentException*。

这使我们能够拥有更灵活的语义并决定抛出的异常，而不是总是看到*NullPointerException*。

现在我们已经很好地理解了如何单独利用 Optional，让我们看看可用于将转换和过滤应用于*Optional*值的其他方法。

#### **转变价值观** ####

*可选*值可以通过多种方式进行转换；让我们从*map()*和 *flatMap()*方法开始。

首先，让我们看一个使用*map()* API 的示例：

@Test
    public void whenMap_thenOk() {
        User user = new User("anna@gmail.com", "1234");
        String email = Optional.ofNullable(user)
          .map(u -> u.getEmail()).orElse("default@gmail.com");
        
        assertEquals(email, user.getEmail());
    }

***map()* 将*Function*参数应用于值，然后返回包装在*Optional*中的结果。**这使得对响应应用和链接进一步的操作成为可能——比如*这里的orElse()*。

相比之下，*flatMap()*还接受一个*Function*参数，该参数应用于*Optional*值，然后直接返回结果。

要查看实际情况，让我们添加一个向*User*类返回*Optional的方法：*

public class User {    
        private String position;
    
        public Optional<String> getPosition() {
            return Optional.ofNullable(position);
        }
        
        //...
    }

由于 getter 方法返回 String 值的*Optional* ，因此您可以将其用作*flatMap()*的参数，其中 this 用于*Optional User*对象。返回将是未包装的*字符串*值：

@Test
    public void whenFlatMap_thenOk() {
        User user = new User("anna@gmail.com", "1234");
        user.setPosition("Developer");
        String position = Optional.ofNullable(user)
          .flatMap(u -> u.getPosition()).orElse("default");
        
        assertEquals(position, user.getPosition().get());
    }

#### **过滤值** ####

除了转换值之外，*Optional*类还提供了根据条件“过滤”它们的可能性。

***filter()*方法将Predicate*作为*参数**，如果测试结果为真，则返回原样。否则，如果测试为假，则返回值为空*Optional*。

让我们看一个基于非常基本的电子邮件验证接受或拒绝*用户的示例：*

@Test
    public void whenFilter_thenOk() {
        User user = new User("anna@gmail.com", "1234");
        Optional<User> result = Optional.ofNullable(user)
          .filter(u -> u.getEmail() != null && u.getEmail().contains("@"));
        
        assertTrue(result.isPresent());
    }

结果对象将包含一个非*空值，**因为*它通过了过滤器测试。

#### ***Optional*类的链接方法** ####

为了更强大地使用*Optional*，您还可以链接其大多数方法的不同组合，因为它们中的大多数返回相同类型的对象。

*让我们使用Optional*重写介绍中的示例。

首先，让我们重构类，以便 getter 方法返回*可选*引用：

public class User {
        private Address address;
    
        public Optional<Address> getAddress() {
            return Optional.ofNullable(address);
        }
    
        // ...
    }

public class Address {
        private Country country;
        
        public Optional<Country> getCountry() {
            return Optional.ofNullable(country);
        }
    
        // ...
    }

上面的结构可以直观地表示为一个嵌套集：

现在您可以删除*空*检查并改用*Optional*方法：

@Test
    public void whenChaining_thenOk() {
        User user = new User("anna@gmail.com", "1234");
    
        String result = Optional.ofNullable(user)
          .flatMap(u -> u.getAddress())
          .flatMap(a -> a.getCountry())
          .map(c -> c.getIsocode())
          .orElse("default");
    
        assertEquals(result, "default");
    }

上面的代码可以通过使用方法引用进一步减少：

String result = Optional.ofNullable(user)
      .flatMap(User::getAddress)
      .flatMap(Address::getCountry)
      .map(Country::getIsocode)
      .orElse("default");

因此，代码看起来比我们早期的繁琐、条件驱动的版本要干净得多。

#### **Java 9 新增功能** ####

在 Java 8 中引入的特性旁边，**Java 9 向 Optional 类添加了另外三个方法：*or()*、*ifPresentOrElse()*和*stream()*。**

*or()*方法与*orElse()*和*orElseGet()*类似，因为它在对象为空时提供替代行为。在这种情况下，返回值是由*Supplier*参数生成的另一个*Optional对象。*

如果对象确实包含值，则不执行 lambda 表达式：

@Test
    public void whenEmptyOptional_thenGetValueFromOr() {
        User result = Optional.ofNullable(user)
          .or( () -> Optional.of(new User("default","1234"))).get();
                     
        assertEquals(result.getEmail(), "default");
    }

在上面的示例中，如果*user*变量为 null，则返回一个*Optional*，其中包含一个带有电子邮件“default”的*User对象。*

ifPresentOrElse *()*方法接受两个参数：*Consumer*和*Runnable*。如果对象包含一个值，则执行*Consumer*动作；否则，执行*Runnable*动作。

如果您想使用存在的值执行操作，或者只是跟踪是否定义了值，则此方法很有用：

Optional.ofNullable(user).ifPresentOrElse( u -> logger.info("User is:" + u.getEmail()),
      () -> logger.info("User not found"));

最后，新的 *stream()方法允许您通过***将实例转换为*****Stream*****对象**来从广泛的*Stream* API中受益。如果不存在任何值，这将是一个空*Stream* ，或者一个包含单个值的 Stream - 如果*Optional**包含*非*空*值。

让我们看一个将*Optional*处理为*Stream*的示例：

@Test
    public void whenGetStream_thenOk() {
        User user = new User("john@gmail.com", "1234");
        List<String> emails = Optional.ofNullable(user)
          .stream()
          .filter(u -> u.getEmail() != null && u.getEmail().contains("@"))
          .map( u -> u.getEmail())
          .collect(Collectors.toList());
       
        assertTrue(emails.size() == 1);
        assertEquals(emails.get(0), user.getEmail());
    }

这里使用*Stream*可以应用*Stream*接口方法*filter()*、*map()*和*collect()*来获取*List*。

#### ***Optional*应该如何 使用** ####

使用*Optional*时需要考虑一些事项，以确定何时以及如何使用它。

重要的一点是***Optional*不是*Serializable***。因此，它不打算用作类中的字段。

如果您确实需要序列化包含*Optional*值[的对象， Jackson库][Jackson]支持将*Optional*视为普通对象。这意味着*Jackson*将空对象视为*null*，将具有值的对象视为包含该值的字段。这个功能可以在[jackson-modules-java8][]项目中找到。

另一种使用类型不是很有帮助的情况是作为方法或构造函数的参数。这会导致代码变得不必要地复杂：

User user = new User("john@gmail.com", "1234", Optional.empty());

相反，使用方法重载来处理非强制性参数要容易得多。

***Optional*的预期用途主要是作为返回类型。**获得此类型的实例后，您可以提取该值（如果存在）或提供替代行为（如果不存在）。

*Optional*类的一个非常有用的用例是将它与返回*Optional*值的流或其他方法结合起来以**构建流畅的 API**。

让我们看一个使用*Stream findFirst()*方法的示例，该方法返回一个*Optional*对象：

@Test
    public void whenEmptyStream_thenReturnDefaultOptional() {
        List<User> users = new ArrayList<>();
        User user = users.stream().findFirst().orElse(new User("default", "1234"));
        
        assertEquals(user.getEmail(), "default");
    }

#### **结论** ####

*Optional*是对 Java 语言的有用补充，旨在最大限度地减少代码中*NullPointerException*的数量，但不能完全删除它们。

它也是对 Java 8 中添加的新功能支持的精心设计且非常自然的补充。

总的来说，这个简单而强大的类有助于创建代码，简而言之，它比其程序对应物更具可读性且不易出错。

[Optional]: http://www.oracle.com/technetwork/articles/java/java8-optional-2175753.html
[Java]: https://stackify.com/content/java/
[Link 1]: https://stackify.com/java-performance-tuning/
[Jackson]: https://stackify.com/java-xml-jackson/
[jackson-modules-java8]: https://github.com/FasterXML/jackson-modules-java8