Java8 Optional类

Optional类是Java8新增的一个类，用于解决NullPointerExxception异常。可以用Optional类来消除代码中的null检查。

• 定义一个Student类：

  public class Student {
  
      private String id;
  
      private String name;
  
      //get set 和 构造方法
  
      @Override
      public String toString() {
          return "Student{" +
              "id='" + id + '\'' +
              ", name='" + name + '\'' +
              '}';
      }
  }
  

• static Optional empty()
  返回空的Optional实例。

  Optional<Object> empty = Optional.empty();
  

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

  Optional<Student> stuOpt = student
              .filter(s -> s.getId() != null && s.getName().equals("yangyang"));
  

• <U>Optional<U> map(Function<? super T,? extends U> mapper)
  如果有值，则对其执行调用映射函数得到返回值。如果返回值不为 null，则创建包含映射返回值的Optional作为map方法返回值，否则返回空Optional。
  map中获取的返回值自动被Optional包装,即返回值 -> Optional<返回值>
  Optional<返回值>使用map会变为Optional<Optional<返回值>>

  String studentName = student
                  .map(s -> s.getName())
                  .orElse("unknown");
  

• <U>Optional<U> flatMap(Function<? super T,Optional<U>> mapper)
  如果值存在，返回基于Optional包含的映射方法的值，否则返回一个空的Optional
  flatMap中返回值保持不变,但必须是Optional类型,即Optional<返回值> -> Optional<返回值>

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

  if (student.isPresent()) {
      student.get()
  }
  

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

  student.ifPresent(s -> {
      if (s.getId() != null) {
          System.out.println(s.getName());
      }
  });
  

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

  if (student.isPresent()) {
      // doSomething
  }
  

• static Optional of(T value)
  返回一个指定非null值的Optional。

  // 返回一个Optional对象,如果参数为空则抛NPE(NullPointerException)异常(空指针异常)
  Optional<Student> stuOpt = Optional.of(student);
  

• static Optional ofNullable(T value)
  如果为非空，返回 Optional 描述的指定值，否则返回空的 Optional。

  // 返回一个Optional对象,如果参数为空则返回一个空对象
  Optional<Student> stuOpt = Optional.ofNullable(student);
  

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

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

  Student stu = new Student();
  stu.setId("123");
  
  Student studentElse = Optional.ofNullable(stu).orElse(new Student("456", "Tom"));
  System.out.println(studentElse);
  
  // 输出
  Student{id='123', name='null'}
  

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

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

  Student stu = null;
  Student studentGet = Optional.ofNullable(stu).orElseGet(() -> new Student("456","Keven"));
  System.out.println(studentGet);   
  
  // 结果
  Student{id='456', name='Keven'}
  

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

  Student stu = null;
  Student studentElse = Optional.ofNullable(stu).orElseThrow(RuntimeException::new);
  System.out.println(studentElse);
  

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