Java8之妙用Optional解决判断Null为空的问题

先来铺垫下已经存在的 Java8 定义的函数式接口：

Java8 Optional库实用操作【简化if else】

我们基本不需要定义自己的函数式接口，Java8 已经给我们提供了大量的默认函数式接口，基本够用，在 rt.jar 包的 java.util.function 目录下可以看到所有默认的函数式接口，大致分为几类：

Function<T,R> T 作为输入，返回的 R 作为输出
Predicate<T> T 作为输入，返回 boolean 值的输出
Consumer<T> T 作为输入，没有输出
Supplier<R> 没有输入 , R 作为输出
BinaryOperator<T> 两个 T 作为输入，T 同样是输出
UnaryOperator<T> 是 Function 的变种，输入输出者是 T

我们先来看看示例：

其它的都是上面几种的各种扩展，只为更方便的使用，下面演示示例，你可以把其当成正常的接口使用，由用户使用 Lambda 传入。

// hello world 示例
Function<String,String> function = (x) -> {return x+"Function";};
System.out.println(function.apply("hello world"));  // hello world Function

UnaryOperator<String> unaryOperator = x -> x + 2;
System.out.println(unaryOperator.apply("9420-"));   // 9420-2

// 判断输入值是否为偶数示例
Predicate<Integer> predicate = (x) ->{return x % 2 == 0 ;};
System.out.println(predicate.test(1));              // false

// 这个没有返回值
Consumer<String> consumer = (x) -> {System.out.println(x);};
consumer.accept("hello world ");                    // hello world

// 这个没有输入 
Supplier<String> supplier = () -> {return "Supplier";};
System.out.println(supplier.get());                 // Supplier

// 找出大数
BinaryOperator<Integer> bina = (x, y) ->{return x > y ? x : y;};
bina.apply(1,2);                                    // 2

接下来我们进入本文要讲解的内容：

let's go ~

if(user!=null){
    Address address = user.getAddress();
    if(address!=null){
        String province = address.getProvince();
    }
}

这种写法是比较丑陋的，为了避免上述丑陋的写法，让丑陋的设计变得优雅。JAVA8提供了Optional类来优化这种写法，接下来的正文部分进行详细说明:

实战：

使用最多：

API介绍

1、Optional(T value),empty(),of(T value),ofNullable(T value)

这四个函数之间具有相关性，因此放在一组进行记忆。

先说明一下，Optional(T value)，即构造函数，它是private权限的，不能由外部调用的。其余三个函数是public权限，供我们所调用。那么，Optional的本质，就是内部储存了一个真实的值，在构造的时候，就直接判断其值是否为空。好吧，这么说还是比较抽象。直接上Optional(T value)构造函数的源码，如下图所示

2、orElse(T other)，orElseGet(Supplier<? extends T> other)和orElseThrow(Supplier<? extends X> exceptionSupplier)

这三个函数放一组进行记忆，都是在构造函数传入的value值为null时，进行调用的。orElse和orElseGet的用法如下所示，相当于value值为null时，给予一个默认值:

@Test
public void test() {
    User user = null;
    user = Optional.ofNullable(user).orElse(createUser());
    user = Optional.ofNullable(user).orElseGet(() -> createUser());
     Object orElseGet = Optional.ofNullable(inss).orElseGet(()-> "sssssss");
}
public User createUser(){
    User user = new User();
    user.setName("zhangsan");
    return user;
}

判断list里的元素:

public static void main(String[] args) {
        Address a1 = new Address("成都");
        Address a2 = new Address("南京");
        Address a3 = new Address("天津");
        Address a4 = new Address("北京");
        List<Address> list = new ArrayList<>();
        List<Address> list1 = new ArrayList<>();
        list.add(a1);list.add(a2);list.add(a3);list.add(a4);
        List<Address> collect = list.stream().filter(a->
            Optional.ofNullable(a).map(address -> address.getCity().contains("京")).get()
        )
        .peek(a -> {
            a.setCity(a.getCity().replace("京","精"));
            list1.add(a);
        })
        .collect(Collectors.toList());
        System.out.println(collect);
        System.out.println(list1);
    }

结果：

[Address{city='南精'}, Address{city='北精'}]
[Address{city='南精'}, Address{city='北精'}]