Optional源码解析与实践

  • Optional源码解析与实践已关闭评论
  • 56 次浏览
  • A+
所属分类:Web前端
摘要

NullPointerException在开发过程中经常遇到,稍有不慎小BUG就出现了,如果避免这个问题呢,Optional就是专门解决这个问题的类,那么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<>();
  5. /**
  6. * If non-null, the value; if null, indicates no value is present
  7. */
  8. 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. }
  10. /**
  11. * Constructs an instance with the value present.
  12. *
  13. * @param value the non-null value to be present
  14. * @throws NullPointerException if value is null
  15. */
  16. private Optional(T value) {
  17. this.value = Objects.requireNonNull(value);
  18. }

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

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)运行结果

Optional源码解析与实践

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)运行结果

Optional源码解析与实践

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(Supplier other): 如果optional不为空,则返回optional中的对象;如果为null,否则调用其他函数并返回调用的结果
  • orElseThrow(Supplier exception): 如果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. }
  24. optional1.ifPresent(t->{
  25. int i =t+1;
  26. System.out.println("optional1处理后的值是"+i);
  27. });
  28. optional2.ifPresent(t->{
  29. int i =t+1;
  30. System.out.println("optional2处理后的值是"+i);});
  31. Integer value3 = 2;
  32. Integer result = optional1.orElse(value3);
  33. System.out.println("optional1执行orElse处理后的值是"+result);
  34. result = optional2.orElse(value3);
  35. System.out.println("optional2执行orElse处理后的值是"+result);
  36. result = optional1.orElseGet(()-> new Integer(-1));
  37. System.out.println("optional1执行orElseGet处理后的值是"+result);
  38. result = optional2.orElseGet(()-> new Integer(-1));
  39. System.out.println("optional2执行orElseGet处理后的值是"+result);
  40. try {
  41. result = optional1.orElseThrow (()-> new RuntimeException("值是空的"));
  42. System.out.println("optional1执行orElseThrow处理后的值是"+result);
  43. }catch (Exception e){
  44. System.out.println("optional1的orElseThrow抛出异常:"+e.getMessage());
  45. }
  46. try {
  47. result = optional2.orElseThrow (()-> new RuntimeException("值是空的"));
  48. System.out.println("optional2执行orElseThrow处理后的值是"+result);
  49. }catch (Exception e){
  50. System.out.println("optional2的orElseThrow抛出异常:"+e.getMessage());
4)运行结果

Optional源码解析与实践

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(Predicate p): 如果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);
  6. Optional<Integer> result =optional1.filter(t->t > 5);
  7. System.out.println("optional1的filter后的值:"+result);
  8. result =optional2.filter(t->t > 5);
  9. System.out.println("optional2的filter后的值:"+result);
4)运行结果

Optional源码解析与实践

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(Function<t, u=""> mapper): 如果存在一个值,则对其应用提供的映射函数,如果结果非空,则返回描述结果的Optional。 否则返回一个空的Optional。
  • flatMap(Function< T,Optional> 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);
  10. System.out.println("optional2的map前的值:"+optional2);
  11. result =optional2.map(t->t.getName());
  12. System.out.println("optional2的map后的值:"+result);
  13. System.out.println("===========flatMap========");
  14. System.out.println("optional1的flatMap前的值:"+optional1);
  15. Optional<Integer> result2 =optional1.flatMap(t->Optional.ofNullable(t.getAge()));
  16. System.out.println("optional1的flatMap后的值:"+result2);
  17. System.out.println("optional2的flatMap前的值:"+optional2);
  18. result2 =optional2.flatMap(t->Optional.ofNullable(t.getAge()));
  19. System.out.println("optional2的flatMap后的值:"+result2);
  20. }
  21. public class User {
  22. String name;
  23. Integer age;
  24. public User(String name,Integer age){
  25. this.name = name;
  26. this.age=age;
  27. }
  28. public String getName() {
  29. return name;
  30. }
  31. public Integer getAge() {
  32. return age;
4)运行结果

Optional源码解析与实践

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京东物流技术与数据智能部
作者:陈昌浩