java中的Optional（一）

Optional作用:主要解决空值针异常

空值针异常：指针：值得是存放的内存地址，空指针指的是当指针不指向任何内存地址时，就叫做空指针。当一个指针不指向任何内存地址，但是你还调用它了，这时候就会产生空指针的异常错误，举例：

int[] array = null; 
System.out.println(array[0]);

这个时候原本array数组是空指针，没有创建新的对象，再调用这个数的时候就会产生空指针异常的错误 ，程序运行显示Exception in thread "main" java.lang.NullPointerException？为什么会产生空指针：int[] array = null再内存中创建了一个叫做array的变量，在对内内存中并没有开辟int类型的数据空间，所以栈内存中的这个array变量没有存放任何内存地址，调用没有的东西显然会产生空指针

* Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
* Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
* Optional 类的引入很好的解决空指针异常
* Optional的构造方法都是被private修饰，所以不能使用new方法创建对象

创建Optional的三个实例：

1.empty()：创建一个包含对象值为空的Optional类对象，获取创建的Optional对象中的值会报错

/*static <T> Optional<T> empty():返回空的Optional实例*/

 2.of(T value):创建对象值非空的Optional类对象，如果将null值传递进去，会报错

/*static <T> Optional<T> of(T value)
返回一个指定非null值的Optional。*/

3.ofNullable(对象参数)：创建一个对象值可以包含空值(null)的Optional类对象，所以不清楚对象是否为null时使用ofNullable

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

Optional类中的方法：

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

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

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

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

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

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

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

/*<U>Optional<U> map(Function<? super T,? extends U> mapper)
如果存在该值，提供的映射方法，如果返回非null，返回一个Optional描述结果，如果为空，最终结果返回一个空的Optional对象，并不会报错*/

/*<U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper)
如果值存在，返回基于Optional包含的映射方法的值，否则返回一个空的Optional*/

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

@Test
    void tes1(){
        Optional<String> optionalS = Optional.of("张三");//参数传递null会发生空值针异常
        Optional.ofNullable(null);
        Optional<Object> opt = Optional.empty();
        System.out.println(opt.isPresent());
    }

 @Test
    void test2(){
        Integer value1 = null;
        Integer value2 = new Integer(10);
        /*static <T> Optional<T> ofNullable(T value)
        如果为非空，返回 Optional 描述的指定值，否则返回空的 Optional。
        重点：允许传递为null参数*/
        Optional<Integer> a = Optional.ofNullable(value1);
        Optional<Integer> b = Optional.ofNullable(value2);
        /*boolean isPresent()如果值存在则方法会返回true，否则返回 false。*/
        System.out.println(a.isPresent());//false 表示Optional中包含的指定值为空
        System.out.println(b.isPresent());//true 表示OPtional中包含非空指定值
        System.out.println(a);//Optional.empty
        System.out.println(b);//Optional[10]

        /*T orElse(T other)如果存在该值，返回值，否则返回 other。*/
        Integer or1 = a.orElse(new Integer(0));//0  由于a是空的Optional,所以返回的new Integer(0)
        /* T get()
        如果在这个Optional中包含这个值，返回值，否则抛出异常：NoSuchElementException*/
        Integer or2 = b.get();//10
        Integer or3 = b.orElse(new Integer(1));//10 b是包含指定值的Optional对象，所以返回包含的指定值
        System.out.println(or1);//0
        System.out.println(or2);//10
        System.out.println(or3);//10
        System.out.println(or1+or2);//10
    }

    @Test
    void test3(){
        /*Stream的findFirst方法在此流中查找第一个元素作为Optional。
        * 如果流中没有元素，findFirst返回空的Optional。如果流没有顺序，那么findFirst可以选择任何元素。
           如果findFirst选择的元素为null，它将抛出NullPointerException*/
        ArrayList<String> list = new ArrayList<>();
        list.add(0,"小伙汁");
        list.add(1,"孙悟空");
        list.add(2,"猪八戒");
        list.add(3,"白龙马");
        list.add(4,"唐三藏");
        list.add(5,"沙和尚");
        Optional<String> dto = list.stream().findFirst();
        if (dto.isPresent()){
            System.out.println(dto.get());
        }
        System.out.println(dto.toString());
    }
    @Test
    void test4(){
        String name = "abcd";
        StringBuilder reverse = new StringBuilder(name).reverse();
        System.out.println(reverse);
    }