Optional是这样用吗?

/**
 * Returns an empty {@code Optional} instance.  No value is present for this
 * Optional.
 *
 * @apiNote Though it may be tempting to do so, avoid testing if an object
 * is empty by comparing with {@code ==} against instances returned by
 * {@code Option.empty()}. There is no guarantee that it is a singleton.
 * Instead, use {@link #isPresent()}.
 *
 * @param <T> Type of the non-existent value
 * @return an empty {@code Optional}
 */
public static<T> Optional<T> empty()

/**
 * 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)

/**
 * 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)

public void ifPresent(Consumer<? super T> consumer)

public<U> Optional<U> map(Function<? super T, ? extends U> mapper)

public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper)

public Optional<T> filter(Predicate<? super T> predicate)

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X;

public void test() {
    String name = getNameById(0);
    if (name!=null) {
        name = name.toUpperCase();
    } else {
        throw new NullPointerException();
    }
}

@Test
public void test() {
    Optional<String> v = Optional.ofNullable(getNameById(0));
    String name = v.map(String::toUpperCase)
            .orElseThrow(NullPointerException::new);
}