Optional 容器类

什么是Optional容器类

Optional 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。

Optional类常用方法：

Optional.of(T t) : 创建一个 Optional 实例。

Optional.empty() : 创建一个空的 Optional 实例。

Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例。

isPresent() : 判断是否包含值。

orElse(T t) : 如果调用对象包含值，返回该值，否则返回t。

orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值。

orElseThrow(Supplier es) ： 当遇到一个不存在的值的时候，并不返回一个默认值，而是抛出异常。

map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()。

flatMap(Function mapper):与 map 类似，要求返回值必须是Optional。

filter(Predicate p)：接收一个函数式接口，当符合接口时，则返回一个Optional对象，否则返回一个空的Optional对象。

示例：

 import org.junit.Test;
 import java.util.Optional;
 /*
  * Optional 容器类：用于尽量避免空指针异常
  *     Optional.of(T t) : 创建一个 Optional 实例
  *     Optional.empty() : 创建一个空的 Optional 实例
  *     Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
  *     isPresent() : 判断是否包含值
  *     ifPresent(Consumer<? super T> consumer) 判断是否包含值，再执行 consumer
  *     orElse(T t) :  如果调用对象包含值，返回该值，否则返回t
  *     orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
  *     orElseThrow(Supplier<? extends X> exceptionSupplier) ： 当遇到一个不存在的值的时候，并不返回一个默认值，而是抛出异常
  *     map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
  *     flatMap(Function mapper):与 map 类似，要求返回值必须是Optional
  *     filter(Predicate<? super T> predicate)：接收一个函数式接口，当符合接口时，则返回一个Optional对象，否则返回一个空的Optional对象
  *
  *     map、flatMap 和 filter 的使用方法和 StreamAPI 中的一样
  */
 public class TestOptional {

     /**
      * 创建 Optional 实例
      */
     @Test
     public void test1(){

         // Optional.empty() : 创建一个空的 Optional 实例
         Optional<String> empty = Optional.empty();
         System.out.println(empty);// 输出结果：Optional.empty
         //System.out.println(empty.get());// 报错：java.util.NoSuchElementException: No value present

         //    Optional.of(T t) : 创建一个 Optional 实例
         Optional<Employee> eop = Optional.of(new Employee());
         System.out.println(eop);// 输出结果：Optional[Employee{name='null', age=null, gender=null, salary=null, status=null}]
         System.out.println(eop.get());//输出结果：Employee{name='null', age=null, gender=null, salary=null, status=null}

         //注意：Optional.of(T t) 中，传递给of()的值不可以为空，否则会抛出空指针异常
         //Optional<Employee> eop1 = Optional.of(null);//这一行直接报错：java.lang.NullPointerException

         //Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
         //所以，在创建Optional对象时，如果传入的参数不确定是否会为Null时，就可以使用 Optional.ofNullable(T t) 方式创建实例。
         Optional<Object> op = Optional.ofNullable(null);//这样的效果和 Optional.empty() 一样
         System.out.println(op);//Optional.empty
         op = Optional.ofNullable(new Employee());//
         System.out.println(op);//Optional[Employee{name='null', age=null, gender=null, salary=null, status=null}]
     }

     /**
      * isPresent() : 判断是否包含值
      * ifPresent(Consumer<? super T> consumer) 判断是否包含值，再执行 consumer
      */
     @Test
     public void test2(){
         Optional<Employee> opt = Optional.of(new Employee());
         System.out.println(opt.isPresent());//输出结果：true
         opt = Optional.ofNullable(null);
         System.out.println(opt.isPresent());//输出结果：false
         opt.ifPresent(employee -> System.out.println(employee));// 如果 opt.isPresent() 为false ，这里就不输出，否则就输出 employee
     }

     /**
      *     orElse(T t) :  如果调用对象包含值，返回该值，否则返回t
      *     orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
      */
     @Test
     public void test3(){
         //Optional<Employee> opt = Optional.of(new Employee());
         Optional<Employee> opt = Optional.ofNullable(null);
         /*Employee emp = opt.orElse(new Employee("张三",20));
         System.out.println(emp);*/

         int condition = 2;//模拟条件
         Employee emp = opt.orElseGet(()-> {
             if (condition == 1){
                 return new Employee("李四");
             }else if (condition == 2){
                 return new Employee("王二麻子");
             }else {
                 return new Employee("赵六");
             }
         });
         System.out.println(emp);
     }
     /**
      *     orElseThrow(Supplier<? extends X> exceptionSupplier) ： 当遇到一个不存在的值的时候，并不返回一个默认值，而是抛出异常
      */
     @Test
     public void test4(){
         Object obj = Optional.ofNullable(null).orElseThrow(IllegalArgumentException::new);//当参数为null，则抛出一个不合法的参数异常
         System.out.println(obj);
     }

 }

备注：map、flatMap 和 filter 的使用方法和 StreamAPI 中的一样，如需了解详细使用方法，请参考：Stream API 详解