java8的Optional类

1.Optional类的使用场景

Optional主要是处理空指针异常的情况，相当于一个容器，当往里面存放对象时，如果对象为空（null），Optional会返回一个空的Optional实例，反之会返回一个非空的Optional实例。

2.Optional实例的创建

由于Optional的构造函数是私有的，无法通过new来创建一个实例.Optional提供以下三个方法来创建实例

Optional.empty();  //返回一个空的Optional实例
Optional.of(T value); //创建一个非空的Optional实例，注意value不能为null，否则包空指针异常
Optional.ofNullable(T value); // 当value为空，相当于有empty()创建实例,非空则相当于of(T value)创建

3.Optional常用的方法

1. isPresent(); 判断Optional里面是否有值，有则为true,否则为false

    Optional<String> op1 = Optional.ofNullable("aaa");
    boolean p1 = op1.isPresent(); // 返回true
    Optional<String> op2 = Optional.ofNullable(null);
    boolean p2 = op2.isPresent(); // 返回false

2. ifPresent(Consumer<? super T> consumer); 判断Optional里面是否有值，有则则执行consumer里面的方法,否则不做任何事

 Optional.ofNullable("cs").ifPresent((t) -> System.out.println("aas1")); // 输出 aas1
 Optional.ofNullable(null).ifPresent((t) -> System.out.println("aas2"));

3. get(); 获取Optional里面的值，为空会报异常(NoSuchElementException)

Optional<String> op1 = Optional.ofNullable("aaa");
String p1 = op1.get(); // 返回aaa
Optional<String> op2 = Optional.ofNullable(null);
String p2 = op2.get(); // 报异常：NoSuchElementException

4. orElse(T value)：如果Optional里面有值，返回该值，否则返回value

Optional<String> op1 = Optional.ofNullable("aaa");
String bbb = op1.orElse("bbb");// 值为aaa
Optional<String> op2 = Optional.ofNullable(null);
String ccc = op2.orElse("ccc"); // 值为ccc

5. orElseGet(Supplier s)：如果Optional里面有值，返回该值，否则返回s获取的值

Optional<String> op1 = Optional.ofNullable("aaa");
String s1 = op1.orElseGet(() -> "bbb"); // 返回aaa
Optional<String> op2 = Optional.ofNullable(null);
String s2 = op2.orElseGet(() -> "ccc"); // 返回ccc

6. orElseThrow(Supplier s)：如果Optional里面有值，返回该值，否则返回自定义的异常

 try {
     Optional.ofNullable("aaa").orElseThrow(() -> new Exception());
 } catch (Exception e) {
     e.printStackTrace();
 }

4.map和flatMap方法

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

map的参数Function第二个对象泛型是U，在返回时会用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));
      }
  }

flatmap的参数Function第二个对象泛型是Optional，在返回时不会包一层Optional，直接返回

String s1 = Optional.ofNullable("aaa")
        .map(value -> "bbb")
        .map(value -> "ddd")
        .map(value -> "eee")
        .orElse("fff"); // 都输出fff

Optional<String> s2 = Optional.ofNullable("aaa")
        .map(value -> "bbb")
        .map(value -> Optional.of("ddd"))
        .map(value -> Optional.of("eee"))
        .orElse(Optional.of("fff"));

String s3 = Optional.ofNullable("aaa")
        .map(value -> "bbb")
        .flatMap(value -> Optional.of("ddd"))
        .flatMap(value -> Optional.of("eee"))
        .orElse("fff");

对比上面的示例可以看到，当Function接口返回的是一个普通对象时，我们选择用map.当Function接口返回的是一个被Optional包装过的对象时，我们选择使用flatmap.若不使用flatmap继续使用map则会被多层Optional包裹，不利于后续的链式调用