java8 判空

青旅半醒 2022-01-27 01:13 486阅读 0赞

[https://www.cnblogs.com/yizhiamumu/p/8999482.html][https_www.cnblogs.com_yizhiamumu_p_8999482.html]

空指针是我们最常见也最讨厌的异常，写过 Java 程序的同学，一般都遇到过 NullPointerException :)

### 初识null ###

详细可以参考【[jdk 1.6 Java.lang.Null.Pointer.Exception ][jdk 1.6 Java.lang.Null.Pointer.Exception]】

—— 为了不抛出这个异常，我们便会写如下的代码：

SysUser user = getUserById(id);
    if (user != null) {
        String username = user.getUsername();
        System.out.println("Username is: " + username); // 使用 username
    }

但是很多时候，我们可能会忘记写 if (user != null) —— 如果在开发阶段就发现那还好，但是如果在开发阶段没有测试到问题，等到上线却出了 NullPointerException ... 画面太美，我不敢继续想下去。

### Optional 的引入 ###

为了解决这种尴尬的处境，JDK 终于在 Java8 的时候加入了 Optional 类。用于避免空指针的出现，也无需在写大量的if(obj!=null)这样的判断了，前提是你得将数据用Optional装着，它就是一个包裹着对象的容器。

Optional 的 javadoc 介绍：

A container object which may or may not contain a non-null value. If a value is present, isPresent() will return true and get() will return the value.

这是一个可以包含或者不包含非 null 值的容器。如果值存在则 isPresent()方法会返回 true，调用 get() 方法会返回该对象。

JDK 提供三个静态方法来构造一个 Optional：

*  1.Optional.of(T value)

该方法通过一个非 null 的 value 来构造一个 Optional，返回的 Optional 包含了 value 这个值。对于该方法，传入的参数一定不能为 null，否则便会抛出 NullPointerException。

*  2.Optional.ofNullable(T value)

该方法和 of 方法的区别在于，传入的参数可以为 null

—— 但是前面 javadoc 不是说 Optional 只能包含非 null 值吗？我们可以看看 ofNullable 方法的源码：

public static <T> Optional<T> ofNullable(T value) {
 return value == null ? empty() : of(value);
 }

进行三目运算，判断传入的参数是否为 null，如果为 null 的话，返回的就是 Optional.empty()。

*  3.Optional.empty()

该方法用来构造一个空的 Optional，即该 Optional 中不包含值 —— 其实底层实现还是 如果 Optional 中的 value 为 null 则该 Optional 为不包含值的状态，然后在 API 层面将 Optional 表现的不能包含 null 值，使得 Optional 只存在 包含值 和 不包含值 两种状态。

![复制代码][copycode.gif]

private static final Optional<?> EMPTY = new Optional<>();
 
 private final T value;
 
 private Optional(){
 this.value = null;
 }

![复制代码][copycode.gif]

前面 javadoc 也有提到，Optional 的 isPresent() 方法用来判断是否包含值，get() 用来获取 Optional 包含的值 —— 值得注意的是，如果值不存在，即在一个Optional.empty 上调用 get() 方法的话，将会抛出 NoSuchElementException 异常。

我们假设 getSysUserById 已经是个客观存在的不能改变的方法，那么利用 isPresent 和 get 两个方法，我们现在能写出下面的代码：

Optional<SysUser> user = Optional.ofNullable(getSysUserById(id));
 if (user.isPresent()) {
 String username = user.get().getUsername();
 System.out.println("Username is: " + username); // 使用 username
 }

好像看着代码是优美了点

—— 但是事实上这与之前判断 null 值的代码没有本质的区别，反而用 Optional 去封装 value，增加了代码量。所以我们来看看 Optional 还提供了哪些方法，让我们更好的（以正确的姿势）使用 Optional。

### Optional 提供的方法 ###

1.ifPresent

public void ifPresent(Consumer<? super T> consumer) {
 if (value != null) {
 consumer.accept(value);
 }
 }

如果 Optional 中有值，则对该值调用 consumer.accept，否则什么也不做。 所以对于上面的例子，我们可以修改为：

Optional<User> user = Optional.ofNullable(getUserById(id));
 user.ifPresent(u -> System.out.println("Username is: " + u.getUsername()));

2.orElse

public T orElse(T other) {
        return value != null ? value : other;
    }

如果 Optional 中有值则将其返回，否则返回 orElse 方法传入的参数。

User user = Optional
            .ofNullable(getUserById(id))
            .orElse(new User(0, "Unknown"));
            
    System.out.println("Username is: " + user.getUsername());

3.orElseGet

public T orElseGet(Supplier<? extends T> ither) {
 return value != null ? value : other.get();
 }

orElseGet 与 orElse 方法的区别在于，orElseGet 方法传入的参数为一个 Supplier 接口的实现 —— 当 Optional 中有值的时候，返回值；当 Optional 中没有值的时候，返回从该 Supplier 获得的值。

User user = Optional
            .ofNullable(getUserById(id))
            .orElseGet(() -> new User(0, "Unknown"));
            
    System.out.println("Username is: " + user.getUsername());

4.orElseThrow

![复制代码][copycode.gif]

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
 if (value != null) {
 return value;
 } else {
 throw exceptionSupplier.get();
 }
 }

![复制代码][copycode.gif]

orElseThrow 与 orElse 方法的区别在于，orElseThrow 方法当 Optional 中有值的时候，返回值；没有值的时候会抛出异常，抛出的异常由传入的 exceptionSupplier 提供。

User user = Optional
            .ofNullable(getUserById(id))
            .orElseThrow(() -> new EntityNotFoundException("id 为 " + id + " 的用户没有找到"));

举一个 orElseThrow 的用途：在 SpringMVC 的控制器中，我们可以配置统一处理各种异常。查询某个实体时，如果数据库中有对应的记录便返回该记录，否则就可以抛出 EntityNotFoundException ，处理 EntityNotFoundException 的方法中我们就给客户端返回Http 状态码 404 和异常对应的信息 —— orElseThrow 完美的适用于这种场景。

![复制代码][copycode.gif]

@RequestMapping("/{id}")
 public SysUser getSysUser(@PathVariable Integer id) {
 Optional<SysUser> user = userService.getSysUserById(id);
 return user.orElseThrow(() -> new EntityNotFoundException("id 为 " + id + " 的用户不存在"));
 }
 
 @ExceptionHandler(EntityNotFoundException.class)
 public ResponseEntity<String> handleException(EntityNotFoundException ex) {
 return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);
 }

![复制代码][copycode.gif]

5.map

![复制代码][copycode.gif]

public Optional map(Function<? super T, ? extends U> mapper) {
 Objects.requireNonNull(mapper);
 if (!isPresent()){
 return empty();
 } else {
 return Optional.ofNullable(mapper.apply(value));
 }
 }

![复制代码][copycode.gif]

如果当前 Optional 为 Optional.empty，则依旧返回 Optional.empty；否则返回一个新的 Optional，该 Optional 包含的是：函数 mapper 在以 value 作为输入时的输出值。

Optional<String> username = Optional
 .ofNullable(getUserById(id))
 .map(user -> user.getUsername());
 
 System.out.println("Username is: " + username.orElse("Unknown"));

而且我们可以多次使用 map 操作：

![复制代码][copycode.gif]

Optional<String> username = Optional
 .ofNullable(getUserById(id))
 .map(user -> user.getUsername())
 .map(name -> name.toLowerCase())
 .map(name -> name.replace('_', ' '));
 
 System.out.println("Username is: " + username.orElse("Unknown"));

![复制代码][copycode.gif]

6.flatMap

![复制代码][copycode.gif]

public Optional flatMap(Function<? super T, Optional> mapper) {
 Objects.requireNonNull(mapper);
 if (!isPresent()){
 return empty();
 } else {
 return Objects.requireNonNull(mapper.apply(value));
 }
 
 }

![复制代码][copycode.gif]

flatMap 方法与 map 方法的区别在于，map 方法参数中的函数 mapper 输出的是值，然后 map 方法会使用 Optional.ofNullable 将其包装为 Optional；而 flatMap 要求参数中的函数 mapper 输出的就是 Optional。

Optional<String> username = Optional
 .ofNullable(getUserById(id))
 .flatMap(user -> Optional.of(user.getUsername()))
 .flatMap(name -> Optional.of(name.toLowerCase()));
 
 System.out.println("Username is: " + username.orElse("Unknown"));

### 7.filter ###

![复制代码][copycode.gif]

public Optional<T> filter(Predicate<? super T> predicate) {
 Objects.requireNonNull(predicate);
 if(!isPresent()) {
 return this;
 } else {
 return predicate.test(value) ? this : empty();
 }
 }

![复制代码][copycode.gif]

filter 方法接受一个 Predicate 来对 Optional 中包含的值进行过滤，如果包含的值满足条件，那么还是返回这个 Optional；否则返回 Optional.empty。

Optional<String> username = Optional
 .ofNullable(getUserById(id))
 .filter(user -> user.getId() < 10)
 .map(user -> user.getUsername());
 
 System.out.println("Username is: " + username.orElse("Unknown"));

有了 Optional，我们便可以方便且优雅的在自己的代码中处理 null 值，而不再需要一昧通过容易忘记和麻烦的 if (object != null) 来判断值不为 null。如果你的程序还在使用 Java8 之前的 JDK，可以考虑引入 Google 的 Guava 库 —— 事实上，早在 Java6 的年代，Guava 就提供了 Optional 的实现。

### 小结 ###

![复制代码][copycode.gif]

1 public class OptionalTest {
 2 public static void main(String[] arg) {
 3 //创建Optional对象，如果参数为空直接抛出异常
 4 Optional<String> str=Optional.of("a");
 5 
 6 //获取Optional中的数据,如果不存在，则抛出异常
 7 System.out.println(str.get());
 8 
 9 //optional中是否存在数据
 10 System.out.println(str.isPresent());
 11 
 12 //获取Optional中的值，如果值不存在，返回参数指定的值
 13 System.out.println(str.orElse("b"));
 14 
 15 //获取Optional中的值，如果值不存在，返回lambda表达式的结果
 16 System.out.println(str.orElseGet(()->new Date().toString()));
 17 
 18 //获取Optional中的值，如果值不存在，抛出指定的异常
 19 System.out.println(str.orElseThrow(()->new RuntimeException()));
 20 
 21 
 22 
 23 Optional<String> str2=Optional.ofNullable(null);
 24 
 25 //optional中是否存在数据
 26 System.out.println(str2.isPresent());
 27 
 28 //获取Optional中的值，如果值不存在，返回参数指定的值
 29 System.out.println(str2.orElse("b"));
 30 
 31 //获取Optional中的值，如果值不存在，返回lambda表达式的结果
 32 System.out.println(str2.orElseGet(()->new Date().toString()));
 33 
 34 //获取Optional中的值，如果值不存在，抛出指定的异常
 35 System.out.println(str2.orElseThrow(()->new RuntimeException()));
 36 }
 37 }

![复制代码][copycode.gif]

运行结果：

![复制代码][copycode.gif]

a
    true
    a
    a
    a
    false
    b
    Mon May 15 20:22:47 CST 2017
    Exception in thread "main" java.lang.RuntimeException
        at OptionalTest.lambda$main$3(OptionalTest.java:42)
        at OptionalTest$$Lambda$4/931919113.get(Unknown Source)
        at java.util.Optional.orElseThrow(Optional.java:290)
        at OptionalTest.main(OptionalTest.java:42)

![复制代码][copycode.gif]

### 示例代码： ###

![复制代码][copycode.gif]

1 package crazy;
 2 
 3 import java.util.Optional;
 4 
 5 class Company {
 6 private String name;
 7 private Optional<Office> office;
 8 
 9 public Company(String name, Optional<Office> office) {
 10 this.name = name;
 11 this.office = office;
 12 }
 13 
 14 public String getName() {
 15 return name;
 16 }
 17 
 18 public Optional<Office> getOffice() {
 19 return office;
 20 }
 21 }
 22 
 23 class Office {
 24 private String id;
 25 private Optional<Address> address;
 26 
 27 public Office(String id, Optional<Address> address) {
 28 this.id = id;
 29 this.address = address;
 30 }
 31 
 32 public String getId() {
 33 return id;
 34 }
 35 
 36 public Optional<Address> getAddress() {
 37 return address;
 38 }
 39 }
 40 
 41 class Address {
 42 private Optional<String> street;
 43 private Optional<String> city;
 44 
 45 public Address(Optional<String> street, Optional<String> city) {
 46 this.street = street;
 47 this.city = city;
 48 }
 49 
 50 public Optional<String> getStreet() {
 51 return street;
 52 }
 53 
 54 public Optional<String> getCity() {
 55 return city;
 56 }
 57 }
 58 
 59 public class OptionalDemo1 {
 60 
 61 public static void main(String[] args) {
 62 Optional<Address> address1 = Optional.of(new Address(Optional.ofNullable(null), Optional.of("New York")));
 63 Optional<Office> office1 = Optional.of(new Office("OF1", address1));
 64 Optional<Company> company1 = Optional.of(new Company("Door Never Closed", office1));
 65 
 66 // What is the street address of company1?
 67 // In which city company1 is located?
 68 Optional<Office> maybeOffice = company1.flatMap(Company::getOffice);
 69 Optional<Address> maybeAddress = office1.flatMap(Office::getAddress);
 70 Optional<String> maybeStreet = address1.flatMap(Address::getStreet);
 71 
 72 maybeStreet.ifPresent(System.out::println);
 73 if (maybeStreet.isPresent()) {
 74 System.out.println(maybeStreet.get());
 75 } else {
 76 System.out.println("Street not found.");
 77 }
 78 
 79 // shorter way
 80 String city = company1.flatMap(Company::getOffice)
 81 .flatMap(Office::getAddress)
 82 .flatMap(Address::getStreet)
 83 .orElse("City is not found.");
 84 
 85 System.out.println("City: " + city);
 86 
 87 // only print if city is not null
 88 company1.flatMap(Company::getOffice)
 89 .flatMap(Office::getAddress)
 90 .flatMap(Address::getCity)
 91 .ifPresent(System.out::println);
 92 
 93 }
 94 }

![复制代码][copycode.gif]

talk is easy ,show you the code

java8的Optional到底有什么用呢?说起来，它比原来的null值判断有什么优势呢？

它实际上可以看做一个容器,容器里可能有一个非null的值，也可能没有。它带来最大的好处，就是代码在语义上政治正确。

比如我们有个Integer类型的列表类FooList，它有两个方法，一个返回列表的长度，一个返回比传入参数小的，最大的那个值。

在没有Optional的时候，代码如下

![复制代码][copycode.gif]

public class FooList {
    
        public Integer size() {
            throw new UnsupportedOperationException();
        }
    
        public Integer maxNumberBelow(Integer upperBound) {
            throw new UnsupportedOperationException();
        }
    
    }

![复制代码][copycode.gif]

语义上的问题在于，size方法一定会返回一个数字，maxNumberBelow则不会。如果列表是空的，size返回0，maxNumberBelow(100)该返回什么呢？

这时大家就八仙过海，各显神通了。

1 直接返回null。比较常用的一个方法。

2 返回一个不合法的值。比如String里的indexOf方法，会返回一个-1。

3 抛一个异常。比如jpa里的EntityNotFoundException。

抛异常是最不可取的形式，首先不讨论是否应该是受检异常，数据库里没有记录就抛异常好像也不符合异常的定义。数据库里查不到数据挺正常的，怎么会是异常呢？

方法签名没办法有效的标识出它是不是每次都能返回合理的值，也没法标识出它无法返回合理的值时的行为。无法返回合理的值是什么表现？返回了null？返回了一个特殊的值？还是throw了异常？在IDE里调用方法的时候根本看不出来，只能看文档！！！  
让开发者好好写文档？不存在的！  
让开发者认真看文档？不存在的！

为啥size返回的Integer可以肆无忌惮的使用，而maxNumberBelow返回的Integer就必须和一个奇奇怪怪的值做比较？种族歧视？  
让开发者分清楚这些？不存在的！

![复制代码][copycode.gif]

public class BarList {
 public Integer size() {
 throw new UnsupportedOperationException();
 }
 
 public Optional<Integer> maxNumberBelow(Integer upperBound) {
 throw new UnsupportedOperationException();
 }
 }

![复制代码][copycode.gif]

首先，返回值就能明确区分出，方法是每次返回合理的值还是有条件的返回合理的值。

其次，IDE还能检查出来对Optional对象跳过isPresent直接调用get方法。

[https_www.cnblogs.com_yizhiamumu_p_8999482.html]: https://www.cnblogs.com/yizhiamumu/p/8999482.html
[jdk 1.6 Java.lang.Null.Pointer.Exception]: http://www.cnblogs.com/yizhiamumu/p/9051312.html
[copycode.gif]: /images/20220127/349409ec7dba47f7b4962d1cd5a1a656.png