optional学习

Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。使用Optional，可以很好的解决空指针异常。

下面对Optional的api进行实践解读

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

我们可以使用下面的方式创建一个空的Optional
Optional.empty()；

boolean equals(Object obj)
判断其他对象是否等于 Optional。

     * Indicates whether some other object is "equal to" this Optional. The
     * other object is considered equal if:
     * <ul>
     * <li>it is also an {
    
    @code Optional} and;
     * <li>both instances have no value present or;
     * <li>the present values are "equal to" each other via {
    
    @code equals()}.
     * </ul>
    通过查看代码中的注解，可以观察到，如果另一个对象也是一个Optional的话，两者都为空或者两者的值相等，equals返回true。

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

        Optional<String> strOpt = Optional.of("much thing to do.");
        System.out.println(strOpt.filter((p) -> p.length() > 0));
        /*输出：
        Optional[much thing to do.]
        */

Optional flatMap(Function<? super T,Optional> mapper)
如果值存在，返回基于Optional包含的映射方法的值，否则返回一个空的Optional
flatmap和map的返回值都是Optional：
但是使用flatmap不会自动将返回值封装成Optional类型的，使用map会自动将返回值封装成为Optional类型的。

        Optional<Integer> strOpt = Optional.of(1);
        System.out.println(strOpt.flatMap((p) -> Optional.of("teststr")));
        // 得到 Optional[teststr]

T get()
如果在这个Optional中包含这个值，返回值，否则抛出异常：NoSuchElementException
void ifPresent(Consumer<? super T> consumer)
如果值存在则使用该值调用 consumer , 否则不做任何事情。

/* 输出 5*/
        Integer i = new Integer(2);
        Optional.ofNullable(i).ifPresent(t -> System.out.println(t + 3));

boolean isPresent()
如果值存在则方法会返回true，否则返回 false。
Optional map(Function<? super T,? extends U> mapper)
如果有值，则对其执行调用映射函数得到返回值。如果返回值不为 null，则创建包含映射返回值的Optional作为map方法返回值，否则返回空Optional。
map自动将返回值转换成为Optional

        Optional<Integer> integerOpt = Optional.of(1);
        System.out.println(integerOpt.map(i -> i + 3));
        // 输出 Optional[4]

static Optional of(T value)
返回一个指定非null值的Optional。如果传入null值的话抛异常
static Optional ofNullable(T value) // 可以传入空
如果为非空，返回 Optional 描述的指定值，否则返回空的 Optional。
T orElse(T other)
如果存在该值，返回值，否则返回 other。
从下面的例子可以看到当值存在的时候，Optional中的函数还是会执行。

    public static void main(String[] args) {
    
    
        Optional<Integer> integerOptional=Optional.ofNullable(1);
        System.out.println(integerOptional.orElse(getintValue()));
    }

    public static int getintValue() {
    
    
        System.out.println("int value function.");
        return 10;
    }
    /*
	int value function.
	1
	*/

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

可以看到当不存在值的时候才会执行参数中的方法。这也是和orElse()的区别

    public static void main(String[] args) {
    
    
        Optional<Integer> integerOptional = Optional.ofNullable(1);
        System.out.println(integerOptional.orElseGet(() -> getintValue()));
    }

    public static int getintValue() {
    
    
        System.out.println("int value function.");
        return 10;
    }
    // 输出： 1

	    public static void main(String[] args) {
    
    
        Optional<Integer> integerOptional = Optional.empty();
        System.out.println(integerOptional.orElseGet(() -> getintValue()));
    }

    public static int getintValue() {
    
    
        System.out.println("int value function.");
        return 10;
    }
    // 输出： int value function.
	//	     10

<X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)
如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常

    public static void main(String[] args) throws DemoException {
    
    
        Optional<Integer> integerOptional = Optional.empty();
                                                       // 可以使用方法引用替换
        System.out.println(integerOptional.orElseThrow(() -> new DemoException()));
    }

    static class DemoException extends Exception{
    
    
        DemoException(){
    
    
            System.out.println("Demo Exception");
        }
    }
}

参考博客：
https://blog.csdn.net/qq_28393323/article/details/81003964

https://www.jianshu.com/p/71e599f8f07a

https://www.runoob.com/java/java8-optional-class.html

猜你喜欢