Java8 新特性04-Optional

文章目录

• ​​优秀的文章​​
• ​​JDK8-Optional​​

• ​​判断参数是否为空​​
• ​​参数为空可以设定默认值​​
• ​​参数实现过滤​​

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

• ​​优化方案1​​
• ​​优化方案2​​
• ​​优化方案3​​

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);
    }

}