Java中Optional.of()方法及源码解析(非常详细!)

前言

在Java中，Optional.of() 方法是 Optional 类中用于创建包含非空值的 Optional 对象的静态方法。在本文中，我们将深入解析 Optional.of() 的语法、使用场景，并通过多个示例详细说明。

方法解析

1. Optional.of() 方法的语法

public static <T> Optional<T> of(T value)

• 参数： 非空的值 value。
• 返回值： 包含指定值的 Optional 对象。

2. 使用示例

2.1 创建包含字符串的 Optional 对象

Optional<String> optional = Optional.of("Hello, World!");

上述代码创建了一个包含字符串 “Hello, World!” 的 Optional 对象。由于传入的值是非空的，因此不会引发 NullPointerException。

2.2 创建包含自定义对象的 Optional 对象

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

Person person = new Person("John Doe");
Optional<Person> optionalPerson = Optional.of(person);

这个示例中，我们定义了一个 Person 类，并使用 Optional.of() 创建了一个包含 Person 对象的 Optional 对象。

2.3 注意事项

Optional<String> optional = Optional.of(null); // 会抛出 NullPointerException

Optional.of() 要求传入的值不能为 null，否则会抛出 NullPointerException。在上述示例中，传入了 null 值，导致抛出异常。

3. 使用场景

Optional.of() 适用于确定值不为空的情况，提供了一种安全的方式来包装非空值，避免了空指针异常。但需要注意确保传入的值非空，否则会引发异常。

源码解析

1. Optional.of() 方法的源码

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

上述源码显示了 Optional.of() 方法的实现。以下是对源码的解析：

• public static <T> Optional<T> of(T value) {: 这是一个静态方法声明，返回类型是 Optional<T>，其中 <T> 是泛型参数，表示 Optional 包含的值的类型。参数 value 是需要包装的非空值。

• return new Optional<>(Objects.requireNonNull(value));: 在方法体内，首先使用 Objects.requireNonNull(value) 确保传入的值不为 null。如果传入的值为 null，Objects.requireNonNull 方法会抛出 NullPointerException。

  然后，通过 new Optional<>(...) 创建一个新的 Optional 对象，将传入的非空值包装在其中。

2. 源码解析总结

• Optional.of() 方法通过 Objects.requireNonNull 确保传入的值非空，否则抛出 NullPointerException。
• 创建了一个新的 Optional 对象，并将传入的非空值包装在其中。

3. 注意事项

在使用 Optional.of() 时，一定要确保传入的值不为 null，否则会导致异常。如果不能确定值是否为 null，建议使用 Optional.ofNullable() 方法。

4. Optional 类的基本结构

在深入解析 Optional.of() 的源码之前，我们先了解一下 Optional 类的基本结构。Optional 类的核心思想是包装可能为 null 的值，提供了一些方法来处理这种情况。

public final class Optional<T> {

    private static final Optional<?> EMPTY = new Optional<>();

    private final T value;

    private Optional() {
        this.value = null;
    }

    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

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

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

    public static <T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

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

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

    // 其他方法省略...
}

上述是 Optional 类的简化版本，其中包含了 of() 方法的源码。关键部分解析如下：

• EMPTY：Optional 类的一个静态常量，表示空的 Optional 对象。
• value：私有字段，用于保存包装的值。
• of(T value)：静态工厂方法，用于创建包含非空值的 Optional 对象。
• ofNullable(T value)：静态工厂方法，用于创建包含可能为 null 值的 Optional 对象。
• empty()：静态工厂方法，用于创建空的 Optional 对象。
• isPresent()：判断 Optional 对象是否包含值。
• get()：获取 Optional 对象中的值，如果值为空则抛出 NoSuchElementException。

6. Optional.of() 源码解析

现在我们来看一下 Optional.of() 方法的源码：

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

这个方法非常简单，它直接调用 Optional 类的私有构造函数 private Optional(T value) 来创建一个新的 Optional 对象，并将传入的值包装在其中。

private Optional(T value) {
    this.value = Objects.requireNonNull(value);
}

在构造函数中，首先通过 Objects.requireNonNull(value) 确保传入的值非空，否则抛出 NullPointerException。然后将非空值保存在 value 字段中。

这就是 Optional.of() 方法的基本逻辑。总体来说，Optional 类提供了一种安全地处理可能为 null 值的方式，而 Optional.of() 则是其中的一个关键方法，用于创建包含非空值的 Optional 对象。

4. 总结

Optional.of() 是创建包含非空值的 Optional 对象的方法。通过深入解析其语法、使用示例以及注意事项，我们更好地理解了该方法的作用和适用场景。在使用时，确保传入的值非空，以保证安全使用 Optional。在不确定值是否为空的情况下，建议使用 Optional.ofNullable() 方法。

附：Optional.of()和Optional.ofNullable()区别

Optional.of()或者Optional.ofNullable()：创建Optional对象，差别在于of不允许参数是null，而ofNullable则无限制。

// 参数不能是null，是null抛异常
Optional<Integer> optional1 = Optional.of(1);
 
// 参数可以是null
Optional<Integer> optional2 = Optional.ofNullable(null);
 
// 参数可以是非null
Optional<Integer> optional3 = Optional.ofNullable(2);

空指针异常是导致Java应用程序失败的最常见原因。以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。Optional实际上是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。

通过of(T value)函数所构造出的Optional对象,当Value值为空时,依然会报NullPointerException。

到此这篇关于Java中Optional.of()方法及源码解析的文章就介绍到这了,更多相关Java Optional.of()方法源码解析内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

最新评论