JDK1.8中Optional详解

/**
 * @Author lim
 * @Date 2019/4/26 11:08
 * @Description Optional
 */
public class OptionalTest {

    public static void main(String[] args) {

        OptionalTest optionalTest = new OptionalTest();
        optionalTest.test(new Leader());

    }


    public void test(Leader leader){

        /**
         * empty
         * 返回一个空的Optional
         */
        //Optional<Object> empty = Optional.empty();

        /**
         * of
         * 将传入的值,封装为Optional对象,如果值为NULL,则抛出NullPointerException
         */
        //Optional<Leader> leaderOptional = Optional.of(leader);

        /**
         * ofNullable
         * 将传入的值,封装为Optional对象,如果值为NULL,则返回一个空的Optional对象
         */
        //Optional<Leader> leaderOptional = Optional.ofNullable(leader);

        /**
         * get
         * 获取Optional中的值,如果有值返回,否则抛出NoSuchElementException
         */
        //Leader tempLeader = Optional.ofNullable(leader).get();

        /**
         * isPresent
         * 判断Optional中的值是否为NULL,不为NULL返回true,否则返回false
         */
        //boolean present = Optional.ofNullable(leader).isPresent();

        /**
         * ifPresent
         * 如果Optional中值不为NULL,传入ifPresent中定义的函数进行消费处理,否则不执行任何操作
         */
        /*Optional.ofNullable(leader).ifPresent(a -> {
            a.setAge(12);
            System.out.println(a);
        });*/

        /**
         * filter
         * 如果Optional中的值不为NULL,传入filter中定义的函数进行判断,匹配返回一个包含该值得Optional,否则返回一个空的Optional
         */
       /* boolean present = Optional.ofNullable(leader).filter(a -> {
            if (a.getName() == null) {
                a.setName("张三");
                return true;
            }
            return false;
        }).isPresent();
        System.out.println(present);*/

        /**
         * map
         * 如果Optional中的值不为NULL,则将值传入map中定义的函数进行处理,最后将函数中返回的值封装到全新的Optional中返回
         * 如果为NULL,则返回传入的Optional
         */
        /*leader = null;
        boolean present = Optional.ofNullable(leader).map(a -> {
            a.setName("李四");
            return a;
        }).isPresent();
        System.out.println(present);*/

        /**
         * flatMap
         * 如果Optional中的值不为NULL,则将值传入flatMap中定义的函数进行处理,最后将函数中返回的值封装到全新的Optional中返回(手动封装为Optional)
         * 如果为NULL,则返回传入的Optional
         */
        /*Leader tempLeader = Optional.ofNullable(leader).flatMap(a -> {
            a.setName("李四");
            return Optional.of(a);
        }).get();
        System.out.println(tempLeader);*/

        /**
         * orElse
         * 如果Optional中的值不为NULL,则返回原值,否则返回orElse中定义的值
         */
        /*leader = null;
        Leader tempLeader = Optional.ofNullable(leader).orElse(new Leader());
        System.out.println(tempLeader);*/

        /**
         * orElseGet
         * 如果Optional中的值不为NULL,则返回原值,否则返回orElseGet中定义的Supplier函数
         * 与orElse的区别,如果传入的值为NULL,orElseGet才会被调用,而orElse无论值是否为NULL,都会被调用
         */
        /*Leader tempLeader = Optional.ofNullable(leader).orElseGet(Leader::new);
        System.out.println(tempLeader);*/

        /**
         * orElseThrow
         * 如果Optional中的值不为NULL,则返回原值,否则抛出异常
         */
       /* Leader tempLeader = Optional.ofNullable(leader).orElseThrow(RuntimeException::new);
        System.out.println(tempLeader);*/


        /**
         * 举例
         */
        /*Optional.ofNullable(leader).
                map(leader2 -> {
                    System.out.println("leader2=="+leader2);
                    return leader2.getList();
                }).map(list -> {
                    System.out.println("list=="+list);
                    return list.get(0);
                }).map(l -> l.getName()).ifPresent(s -> System.out.println(s));*/

       /* Optional.ofNullable(leader)
                .flatMap(leader2 -> {
                    System.out.println("leader2==" + leader2);
                    return Optional.ofNullable(leader2.getList());
                }).flatMap(list -> {
                    System.out.println("list==" + list);
                    return Optional.ofNullable(list.get(0));
                }).flatMap(l -> {
                    return Optional.ofNullable(l.getName());
                }).ifPresent(s -> System.out.println(s));*/
    }
}