引言

Optional是Java8新引入的一个类，主要用于解决空指针异常问题。

创建Optional实例

//当of() 方法参数为null时，会抛出 NullPointerException
Optional<String> emptyOpt = Optional.of(null);

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

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

使用Optional.ofNullable()创建Optional实例

 Optional<String> emptyOpt = Optional.ofNullable(null);

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;
    }
  private static final Optional<?> EMPTY = new Optional<>();

访问Optional对象的值

 Optional<String> emptyOpt = Optional.ofNullable(null);
//  当值为null是，会抛出异常
       emptyOpt.get();

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

判断是否有值

Optional<String> emptyOpt = Optional.ofNullable(null);
emptyOpt.isPresent();

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

//如果不为空，则执行Lambda表达式
 public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
 }

当对象为空时，返回默认值

//当传入的值为空时，返回 orElse（）方法参数
Object other = Optional.ofNullable(null).orElse("other");
// 如果orElse 传入的参数是一个函数，函数都会在每次调用这个方法时都会执行
public T orElse(T other) {
      return value != null ? value : other;
 }

当返回的默认值为一个函数时,采用orElseGet()更有可能提高性能，避免不必要的函数被执行

Object othe1r = Optional.ofNullable("hhh").orElseGet(() -> anInt());

public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}

转换值（map)

Object other = Optional.ofNullable("hhh").map(String::toUpperCase);  //Optional[HHH]

  /**
     * 
     * @param mapper
     * @return Optional<T> 对象
     */
 public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
     //判断mapper 是否为空 ，如果为空，则抛出 NullPointerException
        Objects.requireNonNull(mapper);
     //判断 value 值是否为 null 
        if (!isPresent())
            return empty();
        else {
            //创建一个新的Optional对象
            return Optional.ofNullable(mapper.apply(value));
        }
    }

过滤值filter（）

 Object other = Optional.ofNullable("hhh").filter(String::isEmpty);
 

/**
     * 
     * @param mapper
     * @return  如果不满足过滤条件，则返回一个空的Optional 对象
     */
public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }