Optional-------NPE

Optional

对象容器

一定程度上避免了NPE(操作不当仍然会引起NPE)

用于可选值而非空引用的类级别的解决方案

不用Optional之前：只要操作对象，为了防止NPE，必须添加判空语句

构造函数：

• 构造方法私有，无法通过外部调用

  private static final Optional<?> EMPTY = new Optional<>();
  private final T value;
  private Optional() {
      this.value = null;
  }
  private Optional(T value) {
          this.value = Objects.requireNonNull(value);
  }
  

• 通过静态方法构造Optional对象

  //直接构建一个空的Optional对象
  public static<T> Optional<T> empty() {
          @SuppressWarnings("unchecked")
          Optional<T> t = (Optional<T>) EMPTY;
          return t;
  }
  //直接构建一个非空的Optional对象(value为空报NPE)
  public static <T> Optional<T> of(T value) {
          return new Optional<>(value);
  }
  //直接构建一个Optional对象 --可空，可不空
  public static <T> Optional<T> ofNullable(T value) {
          return value == null ? empty() : of(value);
  }
  

相关方法：

get方法：

• value值为空抛异常

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

isPresent

• 判空(值是否存在)

• 等同于判断一个对象是否非空

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

• 为空返回false，否则返回true

• Java 11 后还可以通过方法 isEmpty() 判断与 isPresent() 相反的结果。(是否为空)

ifPresent

• 如果值不为空，执行相关运算(对value)

• 函数式编程：消费者类型，传参无返回值

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

• Java 9 后还可以通过方法 ifPresentOrElse(action, emptyAction) 执行两种结果，非空时执行 action，空时执行 emptyAction。

orElse：

• 可以设置默认值

• value不为空，返回value，否则返回默认值(默认值可以为空，不报NPE)

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

orElseGet、orElseThrow:

• 传递一个生产者接口，无参，有返回值

• orElseGet：value不为空，返回value，否则返回生产者提供的value，但是生产者为空，会报NPE，如果生产者提供的value为空，不报NPE

• orElseThrow：如果 Optional 存在该值，返回包含的值，否则抛出由 Supplier 继承的异常，生产者为空，会报NPE

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

• 总结：

  1. 如果value为空，orElse、orElseGet、orElseThrow都会去默认值方法
  2. 如果value不为空，orElseGet、orElseThrow不会去调用默认值(生产者接口),但是orElse方法，仍会去执行默认值方法

filter方法：过滤

• 过滤接口，保留条件为true的值，经常结合stream流对集合进行操作

• 传参为一个断言接口，并且不能为空，否则NPE

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

map方法：转换值

• 传参为一个接口，并且不能为空，否则NPE(接口返回值可以为空)

  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));
          }
  }
  

flatMap：转换值

• 如果值存在，返回基于 Optional 包含的映射方法的值，否则返回一个空的 Optional。

• 传参为一个接口，不能为空并且返回值不能为空，否则NPE（接口返回值不可以为空)

  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));
      }
  }
  public static <T> T requireNonNull(T obj) {
          if (obj == null) throw new NullPointerException();
          return obj;
  }