Optional类使用总结

1.1、Optional类介绍

在我们平常开发过程中，如果程序逻辑考虑不全，就有可能导致空指针异常NullPointerException，也就是我们常说的NPE。

出现空指针异常的根本原因，就是我们在使用某个对象的时候，没有判断这个对象是否可以为null，如果这个对象为null，那么在调用其对应方法的时候，就会抛出空指针异常。

在JDK1.7之前，我们可能都是通过如下代码来进行空指针的判断，代码如下所示：

public static void main(String[] args) {
    String obj = null;
    // 判空校验
    if (obj == null) {
        throw new RuntimeException("obj对象不能为空");
    }
}

但是，从JDK1.8开始，就专门提供了一个处理NPE异常的类，即：【Optional】类。

• Optional是一个位于【java.util】包下的类，该类被【final】修饰。
• Optional是一个泛型类，即：可以处理不同数据类型。
• Optional不能直接进行实例化操作，因为它的构造方法是private修饰的。

下面具体介绍一下Optional类的使用方法。

1.2、Optional属性和方法

（1）value属性

Optional类就是判断某个对象是否为空的，所以为了保存那个对象，Optional类中通过一个泛型value维护需要判断NPE的对象。

private final T value;

（2）私有构造方法

Optional可以理解为是一个处理NPE异常的工具类，所以它不需要被外部进行实例化操作，所以Optional类没有对外提供构造方法，它只有两个private修饰的构造方法。

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

（3）empty()方法

如果我们要创建一个value等于null的Optional对象，此时可以调用Optional类的【empty()】方法。

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

（4）of()方法

通过Optional类的【of()】方法，可以创建一个指定value的Optional对象。

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

注意：如果传递的【value】对象等于null，那么调用【of()】方法的时候，就会抛出NullPointerException异常。

（5）ofNullable()方法

【ofNullable()】方法和【of()】方法类似，两者唯一的区别就是：

• 【of()】方法当指定的【value】等于null时候，抛出NPE异常。
• 【ofNullable()】方法当指定的【value】等于null时候，此时会返回一个空的Optional对象，而不会抛出异常。

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

（6）get()方法

get() 方法用于获取Optional对象中的【value】值。如果value等于null，那么此时会抛出【NoSuchElementException】异常。

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

（7）orElse()方法

orElse() 方法用于获取value值，如果获取的value值等于null，那么此时会采用【orElse()】方法指定的参数值作为返回值。

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

（8）orElseGet()方法

【orElseGet()】方法和【orElse()】方法作用类似，只不过【orElseGet()】方法的参数是一个函数式接口类型Supplier，我们在使用【orElseGet()】方法的时候，就可以采用lambada表达式语法。

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

（9）orElseThrow()方法

orElseThrow() 方法和orElseGet() 方法作用类似，orElseThrow() 方法的参数也是一个函数式接口类型Supplier，只不过它需要返回一个Throwable类型的值。

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

（10）isPresent ()方法

isPresent() 方法作用是判断value值是否存在，即：value值是否为null，如果value等于null，则返回false，否则返回true。

PS：present英文单词含义是：【存在】。

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

（11）ifPresent()方法

ifPresent() 方法作用：如果value值不等于null，则调用具体的消费者方法使用value值，否则不做任何处理。

【ifPresent()】方法没有返回值，并且该方法需要传递一个【Consumer】类型的对象。

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

（12）filter()方法

filter() 方法作用：过滤value值，如果value满足过滤的条件，则返回value值，否则返回一个空的Optional对象。

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

（13）map()方法

map() 方法作用：如果value值等于null，则返回一个空的Optional对象，否则通过Function对象进行value值的运算，并将运行结果作为新的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));
    }
}

（14）flatMap()方法

flatMap() 方法作用：如果value值等于null，则返回一个空的Optional对象，否则将一个二维的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));
    }
}