Optional源码分析(未完)

Optional 类是Java8的新特性，Optional是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。

Optional 类的引入很好的解决空指针异常。

先来看看Optional类的解释

/**
 * A container object which may or may not contain a non-null value.
 * If a value is present, {@code isPresent()} will return {@code true} and
 * {@code get()} will return the value.
 *
 * <p>Additional methods that depend on the presence or absence of a contained
 * value are provided, such as {@link #orElse(java.lang.Object) orElse()}
 * (return a default value if value not present) and
 * {@link #ifPresent(java.util.function.Consumer) ifPresent()} (execute a block
 * of code if the value is present).
 *
 * <p>This is a <a href="../lang/doc-files/ValueBased.html">value-based</a>
 * class; use of identity-sensitive operations (including reference equality
 * ({@code ==}), identity hash code, or synchronization) on instances of
 * {@code Optional} may have unpredictable results and should be avoided.
 *
 * @since 1.8
 */

• Optional类是一个可以或不可装载一个非空值的容器，如果当前建值不为空 isPresent()方法将返回true，同时get()方法将返回Optional对象装载的value值。
• 下面也大概介绍了一下追加的几个方法，将会在下面详细解释到。

public final class Optional<T> {
    /**
     * Common instance for {@code empty()}.
     */
    private static final Optional<?> EMPTY = new Optional<>();

    /**
     * If non-null, the value; if null, indicates no value is present
     */
    private final T value;

    /**
     * Constructs an empty instance.
     *
     * @implNote Generally only one empty instance, {@link Optional#EMPTY},
     * should exist per VM.
     */
    private Optional() {
        this.value = null;
    }
    
    /**
     * Constructs an instance with the value present.
     *
     * @param value the non-null value to be present
     * @throws NullPointerException if value is null
     */
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
     …………
}

• 首先看到Optional是一个带<T>的泛型类，这个<T>泛型在后来也会有很大的作用。
• 其次会看到有一个Optional<?> EMPTY常量，这个常量调无参构造器实例化一个Optional对象。
• 无参构造器，将成员变量value赋值为null。

下面介绍Optional的几个常用的静态方法

empty()方法

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

@SuppressWarnings注解的作用是，给编译器一条指令，告诉编译器对注解的代码元素的内部某些警告保持静默，unchecked 执行了未检查的转换时的警告，例如当使用集合时没有用泛型 (Generics) 来指定集合保存的类型。

该静态方法的泛型T都是由调用该方法的Optional的泛型类型决定，empty()方法其实很简单，将该类的常量EMPTY强制转换为相同类型的Optional对象，而这个empty()方法返回的Optional对象的value值为null。

下面是empty()方法的一些测试

@Test(expected = NoSuchElementException.class)
public void whenCreateEmptyOptional_thenNull() {
    Optional<User> optionalUser = Optional.empty();
    optionalUser.get();
}
//测试将会通过，因为此时的optionalUser的value值实则为null，将会抛出NoSuchElementException异常

get()方法

/**
 * If a value is present in this {@code Optional}, returns the value,
 * otherwise throws {@code NoSuchElementException}.
 *
 * @return the non-null value held by this {@code Optional}
 * @throws NoSuchElementException if there is no value present
 *
 * @see Optional#isPresent()
 */
public T get() {
    if (value == null) {
        throw new NoSuchElementException("No value present");
    }
    return value;
}

get()方法是Optional对象用到最多的方法，因为Optional对象的value值需要使用到该方法去获取，有点像Map，但在Optional对象中，一个对象只是一个对象的容器，所以也用不着根据键去获取值。

get()方法的实现：如果该对象的value值不为null，则返回该value。 若该对象的value为null则抛出 NoSuchElementException异常。

of() 和 ofNullable()方法

通过看最开始的源码，大家可以发现，Optional类将自己的两个构造方法全部私有化，那么肯定会开放公共方法供外部访问。

of()方法

/**
 * Returns an {@code Optional} with the specified present non-null value.
 *
 * @param <T> the class of the value
 * @param value the value to be present, which must be non-null
 * @return an {@code Optional} with the value present
 * @throws NullPointerException if value is null
 */
public static <T> Optional<T> of(T value) {
    return new Optional<>(value);
}

of()方法，通过传入的参数，获取到泛型T同时也是作为Optional对象返回值的泛型。

of()方法调用有参构造器，传入T类型的value，接着可以看到有参构造器

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

同时我们也看到它调用了Objects类的requireNonNull方法

public static <T> T requireNonNull(T obj) {
    if (obj == null)
        throw new NullPointerException();
    return obj;
}

也就是说，使用Optional.of(T value)方法，如果传入的对象为null，则会抛出空指针异常。

下面是一些测试的代码

    @Test(expected = NullPointerException.class)
public void whenCreateOfEmptyOptional_thenNullPointerException() {
    User user = null;
//        使用of和ofNullable方法创建包含值的Optional。两个方法不同之处在于如果    
//        将null传入作为参数，of方法会抛出空指针异常。
//        应该在对象明确不为null时使用of方法
    Optional<User> opt = Optional.of(user);
//        若对象可能是null或非null则应该使用ofNullable方法
//        Optional<User> opt = Optional.ofNullable(user);
    }
    
    //该方法测试也将通过，因为调用of()方法时传入的实则是null，同时将抛出NullPointerException

ofNullable()方法

    /**
 * Returns an {@code Optional} describing the specified value, if non-null,
 * otherwise returns an empty {@code Optional}.
 *
 * @param <T> the class of the value
 * @param value the possibly-null value to describe
 * @return an {@code Optional} with a present value if the specified value
 * is non-null, otherwise an empty {@code Optional}
 */
public static <T> Optional<T> ofNullable(T value) {
    return value == null ? empty() : of(value);
}

相比of()方法而言ofNullable()方法对传入null值时的处理更加优雅，可以看到，代码使用了一个三目运算符，若传入参数value为null，则调用empty方法为value赋值为null，若传入参数value不为空，则调用of()方法，因为这个时候of()方法并不会因为传入参数为null而抛出空指针异常。

下面是一些测试的代码

    @Test(expected = NullPointerException.class)
public void whenCreateOfEmptyOptional_thenNullPointerException() {
    User user = null;
//        使用of和ofNullable方法创建包含值的Optional。两个方法不同之处在于如果    将null传入作为参数，of方法会抛出空指针异常。
//        应该在对象明确不为null时使用of方法
//        Optional<User> opt = Optional.of(user);
//        若对象可能是null或非null则应该使用ofNullable方法
    Optional<User> opt = Optional.ofNullable(user);
}
//这时程序并不会通过，因为@Test内容中我们期望它抛出空指针异常，可是使用的是ofNullable()方法，已经对value为null时做了相应的处理

isPresent()方法

    /**
 * Return {@code true} if there is a value present, otherwise {@code false}.
 *
 * @return {@code true} if there is a value present, otherwise {@code false}
 */
public boolean isPresent() {
    return value != null;
}

isPresent()方法对当前Optional对象的value值进行判断，若value为null则返回false，否则返回true。

这里还存在另一个isPresentf()方法

    /**
 * If a value is present, invoke the specified consumer with the value,
 * otherwise do nothing.
 *
 * @param consumer block to be executed if a value is present
 * @throws NullPointerException if value is present and {@code consumer} is
 * null
 */
public void ifPresent(Consumer<? super T> consumer) {
    if (value != null)
        consumer.accept(value);
}

简答地说，Consumer类包含一个抽象方法。该抽象方法对传入的值进行处理，但没有返回值。

Java8支持不用接口直接通过lambda表达式传入参数。

如果Optional实例有值，调用ifPresent()可以接受接口段或lambda表达式。类似下面的代码：

@Test
public void whenCheckIfPresent_thenOk() {
    User user = new User("zsz", 1, "12345");
//        User user = null;
        Optional<User> opt = Optional.ofNullable(user);

        assertTrue(opt.isPresent());

//        检查是否有值的另一个选择是 ifPresent() 方法。
//        该方法除了执行检查，还接受一个Consumer(消费者) 参数，如果对象不是空的，就对执行传入的 Lambda表达式：
        opt.ifPresent( u -> assertEquals(user.getId(), u.getId()));

//        assertEquals(user.getId(), opt.get().getId());
    }

orElse()方法

/**
 * Return the value if present, otherwise return {@code other}.
 *
 * @param other the value to be returned if there is no value present, may
 * be null
 * @return the value, if present, otherwise {@code other}
 */
public T orElse(T other) {
    return value != null ? value : other;
}

orElse()方法，它的工作方式非常直接，如果有值则返回该值，否则利用三目运算符返回传递给它的参数值。

下面是测试的代码

    @Test
public void whenEmptyValue_thenReturnDefault() {
    User user = null;
    User user1 = new User("zsz", 1, "zsz");

//        方法 orElse()，它的工作方式非常直接，如果有值则返回该值，否则返回传递给它的参数值：
//        若user值不为空则忽略orElse()方法的对象
    User result = Optional.ofNullable(user).orElse(user1);

    assertEquals(user1.getId(), result.getId());
}
//上述代码将通过，因为user是一个null对象，所以orElse()方法会根据这个null值返回user1，也就是orElse()方法参数的值

如果对象的初始值不是 null，那么默认值会被忽略

orElseGet()方法

/**
 * Return the value if present, otherwise invoke {@code other} and return
 * the result of that invocation.
 *
 * @param other a {@code Supplier} whose result is returned if no value
 * is present
 * @return the value if present otherwise the result of {@code other.get()}
 * @throws NullPointerException if value is not present and {@code other} is
 * null
 */
public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}

乍一看和orElse()方法差不多，但是他们之间存在着较大的区别

我们先来看看对象为空时他们的行为：

@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("[email protected]", "1234");
}

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

代码输出如下：

Using orElse
Creating New User
Using orElseGet
Creating New User

由此可见，当对象为空而返回默认对象时，行为并无差异。

我们接下来看一个类似的示例，但这里 Optional 不为空

@Test
public void givenPresentValue_whenCompare_thenOk() {
    User user = new User("[email protected]", "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 服务或数据查询，这个差异会对性能产生重大影响。

orElseThrow()方法

/**
 * Return the contained value, if present, otherwise throw an exception
 * to be created by the provided supplier.
 *
 * @apiNote A method reference to the exception constructor with an empty
 * argument list can be used as the supplier. For example,
 * {@code IllegalStateException::new}
 *
 * @param <X> Type of the exception to be thrown
 * @param exceptionSupplier The supplier which will return the exception to
 * be thrown
 * @return the present value
 * @throws X if there is no value present
 * @throws NullPointerException if no value is present and
 * {@code exceptionSupplier} is null
 */
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    if (value != null) {
        return value;
    } else {
        throw exceptionSupplier.get();
    }
}

除了 orElse() 和 orElseGet() 方法，Optional 还定义了 orElseThrow() API —— 它会在对象为空的时候抛出异常，而不是返回备选的值：

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

这里，如果 user 值为 null，会抛出 IllegalArgumentException。

这个方法让我们有更丰富的语义，可以决定抛出什么样的异常，而不总是抛出 NullPointerException。

map()方法

/**
 * If a value is present, apply the provided mapping function to it,
 * and if the result is non-null, return an {@code Optional} describing the
 * result.  Otherwise return an empty {@code Optional}.
 *
 * @apiNote This method supports post-processing on optional values, without
 * the need to explicitly check for a return status.  For example, the
 * following code traverses a stream of file names, selects one that has
 * not yet been processed, and then opens that file, returning an
 * {@code Optional<FileInputStream>}:
 *
 * <pre>{@code
 *     Optional<FileInputStream> fis =
 *         names.stream().filter(name -> !isProcessedYet(name))
 *                       .findFirst()
 *                       .map(name -> new FileInputStream(name));
 * }</pre>
 *
 * Here, {@code findFirst} returns an {@code Optional<String>}, and then
 * {@code map} returns an {@code Optional<FileInputStream>} for the desired
 * file if one exists.
 *
 * @param <U> The type of the result of the mapping function
 * @param mapper a mapping function to apply to the value, if present
 * @return an {@code Optional} describing the result of applying a mapping
 * function to the value of this {@code Optional}, if a value is present,
 * otherwise an empty {@code Optional}
 * @throws NullPointerException if the mapping function is null
 */
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));
    }
}

map()方法注释说明很多，我们来好好解释一下这个方法。

来看一个例子

@Test
public void whenMap_thenOk() {
    User user = new User("zsz", 1, "zsz");
    int id = Optional
            .ofNullable(user)
            .map(u -> u.getId())
            .orElse(2);

    assertEquals(id, user.getId());
}