java8特性之Optional | 易学教程

java8特性之Optional

optional是一个用来隐式进行非空检测的一个容器，不需要显式的进行null之判断构造函数全部私有化，所以提供了3个静态公开的方法进行optional的初始化，下来我们学习一下！

初始化：
Optional<T> Optional.empty()
Optional<T> Optional.of(T value)
Optional<T> Optional.ofNullable(T value)
从上到下进行讲解，
方法一直接得到一个空值得Optional容器；
方法二，value为null时报空指针异常，否则返回value值的Optional容器
方法三，value为null返回一个空值Optional对象，相当于调用了方法一，否则返回value值的Optional容器

获得null检测结果：
boolean isPresent() optional容器为空，返回false，否则返回true

获得Optional对象的值：
T get() 空容器，报NoSuchElementException,否则返回容器中的值

值非空，则进行消费：
void ifPresent(Consumer<? super T> consumer) optional容器中值为null，不做任何处理;否则进行括号中的消费处理,consumer为null，抛出空指针

空值，则进行异常抛出
// Optional.ofNullable(null).orElseThrow(() -> new Exception("没毛病 ==》你麻痹"));
Optional.ofNullable(null).orElseThrow(() -> { return new Exception("没毛病 ==》你麻痹"); });

空值的默认值处理：
T orElse(T other)
T orElseGet(Supplier<? extends T> other)
<X extends Throwable>T orElseThrow(Supplier<? extends X> exceptionSupplier)
方法一，optional容器中值为null，返回other值为默认值，否者返回optional容器中值
方法二，optional容器中值为null，返回Supplier接口返回值为默认值，否则返回optional容器中值
方法三，optional容器中值为null，抛出exceptionSupplier接口生成的异常，否则返回optional容器中值

非null的转化处理：
Optional<U> map(Function<? super T,? extends U> mapper)
Optional<U> flatMap(Function<? super T,Optional<U>> mapper)
方法一，optional容器中值为null，返回空optional，否则进行Function函数获得转换值的Optional容器，mapper为null抛出空指针
方法二，optional容器中值为null，返回空optional，否则进行Function函数获得转换值的Optional容器，mapper为null抛出空指针
区别：方法一，mapper返回结果会自动进行Optional封装，而方法二返回结果不会进行自动封装，所以方法二返回结果必须为Optional

判断过滤：
Optional<T> filter(Predict<? super T> predict)
optional容器中值不为null，且符合断言，则返回该值的Optional，否则返回空的Optional

下来看示例：

//初始化
Optional<Integer> empty = Optional.empty();
Optional<Integer> value1 = Optional.of(1);
Optional<Integer> value = Optional.ofNullable(null);

// 获得值
System.out.println(value1.get());                                                    //1

//判断空值
System.out.println(value1.isPresent());                                              //true

//非空进行消费,非空打印，否则不进行打印
value1.ifPresent(v -> {
    System.out.println(v);                                                           //1
});
// 或 value1.ifPresent(System.out::print);

//默认值处理
System.out.println(empty.orElse(5));                                          //结果5
System.out.println(value1.orElse(5));                                         //结果1
System.out.println(empty.orElseGet(()->{return 8;}));                               //结果8
try {
    System.out.println(value.orElseThrow(()-> new Exception("我发现了null")));     //抛出自定义异常
} catch (Exception e) {
    e.printStackTrace();
}

//转换
System.out.println(value1.map(a -> (a + 1)).get());                                 //2
System.out.println(value1.flatMap(a -> Optional.of(a+1)).get());                    //2

//过滤
System.out.println(value1.filter(a -> (a>0)).get());                                //1

来源：oschina

链接：https://my.oschina.net/u/2757387/blog/2992622

标签

superT

java

optional