工具类 Optional 用法详解

共计 3537 个字符，预计需要花费 9 分钟才能阅读完成。

Optional 类是 Java 8 中引入的一个用于避免空指针异常的工具类，请注意它是 java.util 包下的一个工具类。

它提供了一系列方法，用于对可能为 null 的对象进行操作，以便更加安全地访问对象的属性和方法。

Optional 里面几乎全部都围绕其中的一个成员变量 value 在运作。

下面是 Optional 类中常用的方法及其用法：

1. of 方法

创建一个包含指定对象的 Optional 对象，如果指定对象为 null，则抛出 NullPointerException 异常。

String str = "Hello, world!";
Optional<String> opt = Optional.of(str);

2. ofNullable 方法

创建一个包含指定对象的 Optional 对象，如果指定对象为 null，则返回一个空的 Optional 对象。

String str = null;
Optional<String> opt = Optional.ofNullable(str);

3. empty 方法

创建一个空的 Optional 对象。

Optional<String> opt = Optional.empty();

4. get 方法

获取 Optional 对象中的值，如果对象为空，则抛出 NoSuchElementException 异常。

Optional<String> opt = Optional.of("Hello, world!");
String str = opt.get();

5. isPresent 方法

判断 Optional 对象中是否包含非 null 的值。

Optional<String> opt = Optional.of("Hello, world!");
if (opt.isPresent()) {
    System.out.println(opt.get()); // 输出：Hello, world!
}

6. orElse 方法

获取 Optional 对象中的值，如果对象为空，则返回指定的默认值。

Optional<String> opt1 = Optional.ofNullable(null);
String str1 = opt1.orElse("default value");
System.out.println(str1); // 输出：default value

Optional<String> opt2 = Optional.of("Hello, world!");
String str2 = opt2.orElse("default value");
System.out.println(str2); // 输出：Hello, world!

7. orElseGet 方法

获取 Optional 对象中的值，如果对象为空，则使用指定的 Supplier 函数生成一个默认值。

Optional<String> opt1 = Optional.ofNullable(null);
String str1 = opt1.orElseGet(() -> "default value");
System.out.println(str1); // 输出：default value

Optional<String> opt2 = Optional.of("Hello, world!");
String str2 = opt2.orElseGet(() -> "default value");
System.out.println(str2); // 输出：Hello, world!

8. orElseThrow 方法

获取 Optional 对象中的值，如果对象为空，则抛出指定的异常。

Optional<String> opt1 = Optional.ofNullable(null);
String str1 = opt1.orElseThrow(() -> new RuntimeException("Object is null")); //  运行抛出异常

Optional<String> opt2 = Optional.of("Hello, world!");
String str2 = opt2.orElseThrow(() -> new RuntimeException("Object is null"));

9. ifPresent 方法

上面提到过 ifPresent 方法，这个方法是重载方法，需要传递一个Consumer 接口的实现类进去。如果 Optional 对象中包含非 null 的值，则执行指定的操作。

Consumer 接口是 Java 8 中引入的一个函数式接口，它表示一个接受单个输入参数并且不返回任何结果的操作。它定义了一个名为 accept 的抽象方法，用于执行操作。Consumer 接口常常用于对集合或流中的元素进行迭代，并对它们进行特定的处理，比如打印、修改或过滤等。

Optional<String> opt = Optional.of("Hello, world!");
opt.ifPresent(System.out::println); // 输出：Hello, world!

源码中可以看见，判读值不为空则执行传递进来的函数。

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

10. filter 方法

该方法接收一个 Predicate 接口的实现类，对 Optional 对象中的值进行过滤，返回一个新的 Optional 对象。

Predicate 接口是 Java 8 中引入的一个函数式接口，它表示一个能够接受一个输入参数并返回一个布尔值的操作。Predicate 接口定义了一个名为 test 的抽象方法，用于执行操作。test 方法接受一个泛型参数 T，表示要测试的对象，返回一个布尔值表示测试结果。

Optional<String> opt1 = Optional.of("Hello, world!");
Optional<String> opt2 = opt1.filter(s -> s.contains("o"));

源码中可以看见如果 test 方法返回为 true，则返回自身，否则返回一个空的 Optional。

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

11. map 方法

该方法接收一个 Function 接口的实现类，对 Optional 对象中的值进行映射，返回一个新的 Optional 对象。

Function 接口是 Java 8 中引入的一个函数式接口，它表示一个能够接受一个输入参数并返回一个结果的操作。Function 接口定义了一个名为 apply 的抽象方法，用于执行操作。apply 方法接受一个泛型参数 T，表示输入参数的类型，返回一个泛型参数 R，表示操作的结果类型。

Optional<String> opt1 = Optional.of("Hello, world!");
Optional<Integer> opt2 = opt1.map(String::length);
System.out.println(opt2.get()); // 输出：13

源码中可以看见，将函数的返回值赋值给了 ofNullable 方法，而这个方法会返回一个 新的 Optional 对象，所以这也是什么 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));
    }
}

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

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

12. flatMap 方法

flatMap 方法也受一个函数作为参数，该函数定义了如何将 Optional 对象中的值进行转换，但是该函数返回值必须是另一个 Optional 对象。

Optional<String> opt1 = Optional.of("Hello, world!");
Optional<Integer> opt2 = opt1.flatMap(s -> Optional.of(s.length()));

提醒：本文发布于494天前，文中所关联的信息可能已发生改变，请知悉！