一、Optional简介

NPE（NullPointerException）是Java应用程序中常见的异常。过去，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。如今，受到Google Guava的启发，Java 8引入了一个同名的Optional类，可以用它来封装可能为空的引用，但它绝不是终结空指针，更多的是提醒你需要关注null的情况，Optional类提供很多有用的方法，这样我们就不用显式进行空值检测。

Optional：按照字面英文解释为“可选的” 意思，但此处的语义是指某个值可能有也可能没有（null）。

Optional 被定义为一个简单的容器，它可以保存类型T的值,其值可能是null或者不是null。在Java 8之前一般某个函数应该返回非空对象但是偶尔却可能返回了null，而在Java 8 以后，不推荐你返回null而是返回Optional。

Optional官方文档地址：http://docs.oracle.com/javase/8/docs/api/java/util/Optional.html

二、Optional的方法及使用

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

2.1、构造函数

• private Optional():构建一个空的 Optional 实例。实例中的 value == null

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

• private Optional(T var1):构建一个Optional 实例。实例中的 value == var1。var1为NULL会抛NPE

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

2.2、获取 Optional 实例方法

• public static<T> Optional<T> empty():返回空的 Optional 实例

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

• public static <T> Optional<T> of(T value):返回一个指定非null值的Optional

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

• public static <T> Optional<T> ofNullable(T value):如果value值非空，返回 Optional 描述的指定值，否则返回空的 Optional

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

示例代码：

      // 创建一个值为空的Optional对象
      Optional<Object> emptyOptional = Optional.empty();

      // 创建一个值非空的Optional对象
      Optional<String> ofOptional = Optional.of("optional");

      // 创建一个值允许为空的Optional对象
      Optional<Object> ofNullableOptional = Optional.ofNullable(null);

2.3、获取 Optional 实例中的 value

• public T get():如果在这个Optional中包含这个值，返回值，否则抛出异常：NoSuchElementException

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

• public T orElse(T other):如果存在该值，返回值， 否则返回 other

public T orElse(T other) {
        return value != null ? value : other;
    }

• public T orElseGet(Supplier<? extends T> other):如果存在该值，返回值， 否则触发 other，并返回 other 调用的结果

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

• public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) :如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

示例代码：

     // get() 如果在这个Optional中包含这个值,返回值，否则抛出异常：NoSuchElementException
     System.out.println("optional get value:" + Optional.of("getValue").get());

     try {
         // 在空的Optional实例上调用get()，抛出NoSuchElementException
         System.out.println(Optional.empty().get());
     }catch (NoSuchElementException e){
         System.out.println(e.getMessage());
     }

     // orElse() 如果存在该值，返回值,否则返回 other
     System.out.println("empty Optional orElse value:" + Optional.empty().orElse("orElseValue"));
     System.out.println("full Optional orElse value:" + Optional.of("optional").orElse("orElseValue"));

     // orElseGet() 如果存在该值,返回值,否则触发 other,并返回 other 调用的结果
     System.out.println("empty Optional orElseGet value:" + Optional.ofNullable(null).orElseGet(() -> "orElseGetValue"));
     System.out.println("full Optional orElseGet value:" + Optional.of("fullValue").orElseGet(() -> "orElseGetValue"));

     // orElseThrow() 如果存在该值,返回包含的值,否则抛出异常
     System.out.println("Optional orElseThrow value:" + Optional.of("optional").orElseThrow(() -> new RuntimeException("Unknown")));
     try {
         // orElseThrow会抛出lambda表达式或方法生成的异常
         Optional.empty().orElseThrow(() -> new RuntimeException("Unknown"));
     }catch (RuntimeException e){
         System.out.println(e.getMessage());
     }

运行结果：

optional get value:getValue
No value present
empty Optional orElse value:orElseValue
full Optional orElse value:optional
empty Optional orElseGet value:orElseGetValue
full Optional orElseGet value:fullValue
Optional orElseThrow value:optional
Unknown

2.4、判断 Optional 是否存在

• public boolean isPresent():如果值存在则方法会返回true，否则返回 false

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

• public void ifPresent(Consumer<? super T> consumer):如果值存在则使用该值调用 consumer ，否则不做任何事情

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

示例代码：

    // 判断Optional对象中的值是否存在
    System.out.println("optional isPresent:" + Optional.empty().isPresent());
    System.out.println("optional isPresent:" + Optional.of("isPresent").isPresent());

    // 如果值存在则使用该值调用 consumer , 否则不做任何事情
    Optional.of("exist").ifPresent(opt -> {
        System.out.println("optional value:" + opt);
    });
    Optional.empty().ifPresent(opt -> {
        System.out.println("optional value:" + opt);
    });

运行结果：

optional isPresent:false
optional isPresent:true
optional value:exist

2.5、判断是否相等

• public boolean equals(Object obj):判断其他对象是否等于 Optional。Optional 实例中的 value 为 NULL 也不会有异常，而是会正常进行比较。

public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (!(obj instanceof Optional)) {
            return false;
        }

        Optional<?> other = (Optional<?>) obj;
        return Objects.equals(value, other.value);
    }

2.6、其他 Lambda 表达式的操作

• public Optional<T> filter(Predicate<? super T> predicate):如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional

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

• public<U> Optional<U> map(Function<? super T, ? extends U> mapper):如果有值，则对其执行调用映射函数得到返回值。如果返回值不为 null，则创建包含映射返回值的Optional作为map方法返回值，否则返回空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<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper):如果值存在，返回基于Optional包含的映射方法的值，否则返回一个空的Optional

public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Objects.requireNonNull(mapper.apply(value));
        }
    }

示例代码：

    // filter() 如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional
    Optional.of("filter").filter(str -> str.equals("filter")).ifPresent(str -> System.out.println("optional value:" + str));
    System.out.println("optional isPresent:" + Optional.empty().filter(str -> str.equals("filter")).isPresent());

    // map() 方法将Optional中的包装对象用Function函数进行运算，并包装成新的Optional对象
    System.out.println("[map]转化成大写:" + Optional.of("map").map(opt -> opt.toUpperCase()).get());

    // flatMap() 方法与map()方法类似，区别在于mapping函数的返回值不同。
    // map()方法的mapping函数返回值可以是任何类型T，而flatMap()方法的mapping函数必须是Optional
    System.out.println("[flatMap]转化成大写:" + Optional.of("flatMap").flatMap(opt -> Optional.of(opt.toUpperCase())).get());

运行结果：

optional value:filter
optional isPresent:false
[map]转化成大写:MAP
[flatMap]转化成大写:FLATMAP

2.7、其他方法

• public int hashCode():返回存在值的哈希码，如果值不存在 返回 0

public int hashCode() {
        return Objects.hashCode(value);
    }

• public String toString():返回一个Optional的非空字符串，用来调试

public String toString() {
        return value != null
            ? String.format("Optional[%s]", value)
            : "Optional.empty";
    }