Java8 新特性04-Optional

优秀的文章

JDK8-Optional

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

判断参数是否为空

• ofNullable(可以传递一个空对象)
• Of(不可以传递空对象)
• isPresent()方法会返回true

public class Test01 {

    public static void main(String[] args) {
        /**
         * 1. ofNullable(可以传递一个空对象)
         * 2    of(不可以传递空对象)
         * isPresent true 不为空  isPresent返回 false 为空。
         */
        Integer a1=1;
        Optional<Integer> a=Optional.ofNullable(a1);
        System.out.println(a.isPresent());
    }
}

>>>>>>> true

参数为空可以设定默认值

• 参数为空 可以设置默认值 orElse(10);

• orElseGet 函数接口的形式 默认赋值

  orElse 直接拆掉你默认值

public class Test02 {

    public static void main(String[] args) {
        /**
         * 参数为空 可以设置默认值 orElse(10);
         */
        Integer a1=null;
//        Optional<Integer> a11 = Optional.ofNullable(a1);
//        System.out.println(a11.get());
//        System.out.println(a11.isPresent());
        System.out.println("+++++++++++++++");
        Integer a=Optional.ofNullable(a1).orElse(10);
        System.out.println(a);
    }
}

>>>>>>>>>>>>>+++++++++++++++
>>>>>>>>>>>>>10

参数实现过滤

a11.filter

public class Test03 {

    public static void main(String[] args) {
        /**
         * 实现过滤
         */
        Integer a1 = 19;
        Optional<Integer> a11 = Optional.ofNullable(a1);
        boolean present = a11.filter(integer -> integer > 17).isPresent();
        System.out.println(present);
    }
}

与Lambda表达式结合使用，优化代码

优化方案1

public class TestEnd01 {
    public static void main(String[] args) {
        //优化前
        String may="dazhao";
        if (may!=null){
            System.out.println(may);
        }
        System.out.println("++++++++++++++++++++");
        //优化后
        Optional<String> may1 = Optional.ofNullable(may);
        // 党value 不为空时 则不会调用
        //优化1
        boolean present = may1.isPresent();
        System.out.println(present);
        if (present){
            System.out.println(may);
        }
        //
        //优化2
        may1.ifPresent(System.out::print);
    }
}

优化方案2

public class TestEnd02 {
    private static OrderEntity order;

    public static void main(String[] args) {
        getOrder();
        System.out.println(order.toString());
    }

    private static OrderEntity getOrder() {
        //优化前
//        if (order == null) {
//            return createOrder();
//        }
//        return order;
        //优化后
//        return Optional.ofNullable(order).orElse(createOrder());
        /**
         * orElseGet 函数接口的形式 默认赋值
         * orElse -- 直接拆掉你默认值
         */
        /**
         *
         */
        //优化1
//        return Optional.ofNullable(order).orElseGet(() -> {
//            order=createOrder();
//            return order;
//        });

        return Optional.ofNullable(order).orElseGet(TestEnd02::orElseGet);
    }

    private static OrderEntity createOrder() {
        return new OrderEntity("123123", "niewen");
    }

    private static OrderEntity orElseGet() {
        order = createOrder();
        return order;
    }
}

优化方案3

public class TestEnd03 {


    public static void main(String[] args) {
        String orderName = TestEnd03.getOrderName();
        System.out.println(orderName);
    }

    private static String getOrderName() {
        //优化前
        OrderEntity order = new OrderEntity("123456", "nieWen");
//        if (order != null) {
//            String orderName = order.getOrderName();
//            if (order != null) {
//                return orderName.toLowerCase(Locale.ROOT);
//            }
//        }
//        return null;

        //优化后写法
        return Optional.ofNullable(order).map(orderEntity -> {
            return orderEntity.getOrderName();
        }).map(name -> {
            return name.toLowerCase(Locale.ROOT);
        }).orElse(null);
    }

}