JDK8 Java 中遇到null 和为空的情况,使用Optional来解决。

2018/05/06 20:26
阅读数 46

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

初识null

 

详细可以参考【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 只存在 包含值 和 不包含值 两种状态。

private static final Optional<?> EMPTY = new Optional<>();

private final T value;

private Optional(){
    this.value = null;
}

前面 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
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    if (value != null) {
        return value;
    } else {
        throw exceptionSupplier.get();
    }
}

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

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

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

@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);
}
5.map
public <U> Optional<U> map(Function<? super T, ? extends U> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent()){
        return empty();
    } else {
        return Optional.ofNullable(mapper.apply(value));
    }
}

如果当前 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 操作:

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"));
6.flatMap
public <U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent()){
        return empty();
    } else {
        return Objects.requireNonNull(mapper.apply(value));
    }
    
}

 

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

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

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 的实现。

 

小结

 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 }

运行结果:

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)

 

 

 

示例代码:

 

 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 }

 

talk is easy ,show you the code

 

 

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

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

 

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

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

public class FooList {

    public Integer size() {
        throw new UnsupportedOperationException();
    }

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

}

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

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

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

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

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



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

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

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


public class BarList {
    public Integer size() {
        throw new UnsupportedOperationException();
    }

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

 

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

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

 



 

 

欢迎关注:一只阿木木

 

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部