Optional源码解析与实践

1 导读

NullPointerException在开发过程中经常遇到，稍有不慎小BUG就出现了，如果避免这个问题呢，Optional就是专门解决这个问题的类，那么Optional如何使用呢？让我们一起探索一下吧！

2 源码解析2.1 Optional定义

Optional类是Java8为了解决null值判断问题而创建的容器类，在java.util 下,使用Optional类可以避免显式的null值判断，避免null导致的NullPointerException。首先，Optional是一个容器，它可以保存类型T的值，也可以为null的容器对象。Optional容器只能存一个值。

2.2 Optional的属性1）源码：

1. /**
2. * Common instance for {@code empty()}.
3. */
4. private static final Optional EMPTY = new Optional();
7. /**
8. * If non-null, the value; if null, indicates no value is present
9. */
10. private final T value;

根据源码可以看到Optional有两个属性，一个是为空值准备的EMPTY和泛型值value;

2.3 Optional的方法

Optional除toString()、hashCode() 、equals()等Object的方法外，还包含以下方法。

2.3.1 私有构造方法

1. /**
2. * Constructs an empty instance.
3. *
4. * @implNote Generally only one empty instance, {@link Optional#EMPTY},
5. * should exist per VM.
6. */
7. private Optional() {
8. this.value = null;
9. }
12. /**
13. * Constructs an instance with the value present.
14. *
15. * @param value the non-null value to be present
16. * @throws NullPointerException if value is null
17. */
18. private Optional(T value) {
19. this.value = Objects.requireNonNull(value);
20. }

分别是创建一个空实例和构造一个具有当前值的实例。

2.3.2 创建方法1）源码

1. public static<T> Optional<T> empty() {
2. @SuppressWarnings("unchecked")
3. Optional<T> t = (Optional<T>) EMPTY;
4. return t;
5. }
6. public static <T> Optional<T> of(T value) {
7. return new Optional(value);
8. }
9. public static <T> Optional<T> ofNullable(T value) {
10. return value == null ? empty() : of(value);
11. }

2）方法说明

• empty(）: 创建一个空的 Optional 实例
• of(T t) : 创建一个 Optional 实例，当 t为null时抛出异常
• ofNullable(T t): 创建一个 Optional 实例，但当 t为null时不会抛出异常，而是返回一个空的实例

3）测试代码

1. public static void main(String[] args) {
2. Integer value1 = null;
3. Integer value2 = 1;
4. try {
5. Optional<Integer> optional1 = Optional.empty();
6. System.out.println("optional1创建了");
7. }catch (Exception e){
8. System.out.println("optional1失败了");
9. }
10. try {
11. Optional<Integer> optional2 = Optional.of(value1);
12. System.out.println("optional2创建了");
13. }catch (Exception e){
14. System.out.println("optional2失败了");
15. }
16. try {
17. Optional<Integer> optional3 = Optional.ofNullable(value1);
18. System.out.println("optional3创建了");
19. }catch (Exception e){
20. System.out.println("optional3失败了");
21. }
22. try {
23. Optional<Integer> optional4 = Optional.of(value2);
24. System.out.println("optional4创建了");
25. }catch (Exception e){
26. System.out.println("optional4失败了");
27. }
28. try {
29. Optional<Integer> optional5 = Optional.ofNullable(value2);
30. System.out.println("optional5创建了");
31. }catch (Exception e){
32. System.out.println("optional5失败了");
33. }
34. }

4）运行结果

2.3.3 值获取方法1）源码

1. public T get() {
2. if (value == null) {
3. throw new NoSuchElementException("No value present");
4. }
5. return value;
6. }

2）方法说明

get(): 如果Optional不为空，则返回该Optional容器中的值，否则抛出NoSuchElementExceptio 。

3）测试代码

1. public static void main(String[] args) {
2. Integer value1 = null;
3. Integer value2 = 1;
4. Optional<Integer> optional1 = Optional.ofNullable(value1);
5. Optional<Integer> optional2 = Optional.of(value2);
6. try {
7. Integer result=optional1.get();
8. System.out.println("optional1的值是："+result);
9. }catch (Exception e){
10. System.out.println("optional1的值获取失败,原因:"+e.getMessage());
11. }
12. try {
13. Integer result=optional2.get();
14. System.out.println("optional2的值是："+result);
15. }catch (Exception e){
16. System.out.println("optional2的值获取失败,原因:"+e.getMessage());
17. }
18. }

4）运行结果

2.3.4 判断方法1）源码

1. public boolean isPresent() {
2. return value != null;
3. }
4. public void ifPresent(Consumer<? super T> consumer) {
5. if (value != null)
6. consumer.accept(value);
7. }
8. public T orElse(T other) {
9. return value != null ? value : other;
10. }
11. public T orElseGet(Supplier<? extends T> other) {
12. return value != null ? value : other.get();
13. }
14. public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
15. if (value != null) {
16. return value;
17. } else {
18. throw exceptionSupplier.get();
19. }
20. }

2）方法说明

• isPresent(): 判断optional是否为空，如果空则返回false，否则返回true
• ifPresent(Consumer c): 如果optional不为空，则将optional中的对象传给Comsumer函数
• orElse(T other): 如果optional不为空，则返回optional中的对象；如果为null，则返回 other 这个对象。
• orElseGet(Supplierother): 如果optional不为空，则返回optional中的对象；如果为null，否则调用其他函数并返回调用的结果
• orElseThrow(Supplierexception): 如果optional不为空，则返回optional中的对象；如果为null，则抛出Supplier函数生成的异常

3）测试代码

1. public static void main(String[] args) {
2. Integer value1 = null;
3. Integer value2 = 1;
4. Optional<Integer> optional1 = Optional.ofNullable(value1);
5. Optional<Integer> optional2 = Optional.of(value2);
6. try {
7. if(optional1.isPresent()){
8. System.out.println("optional1的isPresent结果不为空");
9. }else{
10. System.out.println("optional1的isPresent结果为空");
11. }
12. }catch (Exception e){
13. System.out.println("optional1的isPresent判空失败,原因:"+e.getMessage());
14. }
15. try {
16. if(optional2.isPresent()){
17. System.out.println("optional2的isPresent结果不为空");
18. }else{
19. System.out.println("optional2的isPresent结果为空");
20. }
21. }catch (Exception e){
22. System.out.println("optional2的isPresent判空失败,原因:"+e.getMessage());
23. }
26. optional1.ifPresent(t->{
27. int i =t+1;
28. System.out.println("optional1处理后的值是"+i);
29. });
30. optional2.ifPresent(t->{
31. int i =t+1;
32. System.out.println("optional2处理后的值是"+i);});
35. Integer value3 = 2;
36. Integer result = optional1.orElse(value3);
37. System.out.println("optional1执行orElse处理后的值是"+result);
40. result = optional2.orElse(value3);
41. System.out.println("optional2执行orElse处理后的值是"+result);
44. result = optional1.orElseGet(()-> new Integer(-1));
45. System.out.println("optional1执行orElseGet处理后的值是"+result);
48. result = optional2.orElseGet(()-> new Integer(-1));
49. System.out.println("optional2执行orElseGet处理后的值是"+result);
50. try {
51. result = optional1.orElseThrow (()-> new RuntimeException("值是空的"));
52. System.out.println("optional1执行orElseThrow处理后的值是"+result);
53. }catch (Exception e){
54. System.out.println("optional1的orElseThrow抛出异常:"+e.getMessage());
55. }
56. try {
57. result = optional2.orElseThrow (()-> new RuntimeException("值是空的"));
58. System.out.println("optional2执行orElseThrow处理后的值是"+result);
59. }catch (Exception e){
60. System.out.println("optional2的orElseThrow抛出异常:"+e.getMessage());

4）运行结果

2.3.5 过滤方法1）源码

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

2）方法说明

filter(Predicatep): 如果optional不为空，则执行Predicate p，如果p的结果为true，则返回原本的optional，否则返回空的optional

3）测试代码

1. public static void main(String[] args) {
2. Integer value1 = 5;
3. Integer value2 = 6;
4. Optional<Integer> optional1 = Optional.ofNullable(value1);
5. Optional<Integer> optional2 = Optional.of(value2);
8. Optional<Integer> result =optional1.filter(t->t > 5);
9. System.out.println("optional1的filter后的值:"+result);
10. result =optional2.filter(t->t > 5);
11. System.out.println("optional2的filter后的值:"+result);

4）运行结果

2.3.6 映射方法1）源码

1. public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
2. Objects.requireNonNull(mapper);
3. if (!isPresent())
4. return empty();
5. else {
6. return Optional.ofNullable(mapper.apply(value));
7. }
8. }
9. public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
10. Objects.requireNonNull(mapper);
11. if (!isPresent())
12. return empty();
13. else {
14. return Objects.requireNonNull(mapper.apply(value));
15. }
16. }

2）方法说明

• map(Functionmapper): 如果存在一个值，则对其应用提供的映射函数，如果结果非空，则返回描述结果的Optional。 否则返回一个空的Optional。
• flatMap(Function mapper): 如果有值，则对其应用提供的可选映射函数，返回结果，否则返回空的可选函数。 这个方法类似于map(Function)，但是提供的映射器的结果已经是一个可选的，如果调用，flatMap不会用额外的可选的包装它。
• 区别：map会自动将u放到optional中，而flatMap则需要手动给u创建一个optional

3）测试代码

1. public static void main(String[] args) {
2. User user1 = null;
3. User user2 = new User("user2名字",19);
4. Optional<User> optional1 = Optional.ofNullable(user1);
5. Optional<User> optional2 = Optional.of(user2);
6. System.out.println("=========map==========");
7. System.out.println("optional1的map前的值:"+optional1);
8. Optional<String> result =optional1.map(t->t.getName());
9. System.out.println("optional1的map后的值:"+result);
12. System.out.println("optional2的map前的值:"+optional2);
13. result =optional2.map(t->t.getName());
14. System.out.println("optional2的map后的值:"+result);
17. System.out.println("===========flatMap========");
20. System.out.println("optional1的flatMap前的值:"+optional1);
21. Optional<Integer> result2 =optional1.flatMap(t->Optional.ofNullable(t.getAge()));
22. System.out.println("optional1的flatMap后的值:"+result2);
25. System.out.println("optional2的flatMap前的值:"+optional2);
26. result2 =optional2.flatMap(t->Optional.ofNullable(t.getAge()));
27. System.out.println("optional2的flatMap后的值:"+result2);
29. }
30. public class User {
31. String name;
32. Integer age;
33. public User(String name,Integer age){
34. this.name = name;
35. this.age=age;
36. }
39. public String getName() {
40. return name;
41. }
44. public Integer getAge() {
45. return age;

4）运行结果

3 应用实例3.1 错误用法

• 由于Optional并没有实现Serializable接口,所以不能作为类的属性。
• 不要把Optional作为方法的参数。
• 把if(x!=null)直接换成Optional.ofNullable(x).isPresent(),这样有过度编码的嫌疑。
• 直接使用Optional.get()的返回值进行操作，String result =Optional.ofNullable(null).get().toString()；这样还是会抛出异常的。

3.2 建议用法

A类有属性B类，B类有属性C类,C类有name这个字段。
使用Optional之前:

1. if(atest!=null){
2. Btest btest =atest.getBtest();
3. if(btest!=null){
4. Ctest ctest = btest.getCtest();
5. if (ctest != null) {
6. name =ctest.getName();
7. }
8. }
9. }

使用Optional之后:

1. name = Optional.ofNullable(atest).map(t->t.getBtest()).map(t->t.getCtest()).map(t->t.getName()).orElse("默认值");

代码是不是看上去更整洁了呢？

4 总结

通过对Optional源码解析和用例测试代码的运行结果，可以看出使用Optional可以优化null值判断代码，让代码变得更加优雅和整洁。

自猿其说Tech-JDL京东物流技术与数据智能部作者：陈昌浩