乐趣区

关于javascript:Optional源码解析与实践

jiezi

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）源码：

/**
 * Common instance for {@code empty()}.
 */
private static final Optional<?> EMPTY = new Optional<>();
 
 
/**
 * If non-null, the value; if null, indicates no value is present
 */
private final T value;

依据源码能够看到 Optional 有两个属性，一个是为空值筹备的 EMPTY 和泛型值 value;

2.3 Optional 的办法

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

2.3.1 公有构造方法 

/**
 * Constructs an empty instance.
 *
 * @implNote Generally only one empty instance, {@link Optional#EMPTY},
 * should exist per VM.
 */
private Optional() {this.value = null;}
 
 
/**
* Constructs an instance with the value present.
*
* @param value the non-null value to be present
* @throws NullPointerException if value is null
*/
private Optional(T value) {this.value = Objects.requireNonNull(value);
}

别离是创立一个空实例和结构一个具备以后值的实例。

2.3.2 创立办法
1）源码 


public static<T> Optional<T> empty() {@SuppressWarnings("unchecked")
    Optional<T> t = (Optional<T>) EMPTY;
    return t;
}
public static <T> Optional<T> of(T value) {return new Optional<>(value);
}
public static <T> Optional<T> ofNullable(T value) {return value == null ? empty() : of(value);
}

2）办法阐明

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

3）测试代码 


public static void main(String[] args) {
    Integer value1 = null;
    Integer value2 = 1;
    try {Optional<Integer> optional1 = Optional.empty();
        System.out.println("optional1 创立了");
    }catch (Exception e){System.out.println("optional1 失败了");
    }
    try {Optional<Integer> optional2 = Optional.of(value1);
        System.out.println("optional2 创立了");
    }catch (Exception e){System.out.println("optional2 失败了");
    }
    try {Optional<Integer> optional3 = Optional.ofNullable(value1);
        System.out.println("optional3 创立了");
    }catch (Exception e){System.out.println("optional3 失败了");
    }
    try {Optional<Integer> optional4 = Optional.of(value2);
        System.out.println("optional4 创立了");
    }catch (Exception e){System.out.println("optional4 失败了");
    }
    try {Optional<Integer> optional5 = Optional.ofNullable(value2);
        System.out.println("optional5 创立了");
    }catch (Exception e){System.out.println("optional5 失败了");
    }
}

4）运行后果

2.3.3 值获取办法
1）源码 


public T get() {if (value == null) {throw new NoSuchElementException("No value present");
    }
    return value;
}

2）办法阐明

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

3）测试代码 


public static void main(String[] args) {
    Integer value1 = null;
    Integer value2 = 1;
    Optional<Integer> optional1 = Optional.ofNullable(value1);
    Optional<Integer> optional2 = Optional.of(value2);
    try {Integer result=optional1.get();
        System.out.println("optional1 的值是："+result);
    }catch (Exception e){System.out.println("optional1 的值获取失败, 起因:"+e.getMessage());
    }
    try {Integer result=optional2.get();
        System.out.println("optional2 的值是："+result);
    }catch (Exception e){System.out.println("optional2 的值获取失败, 起因:"+e.getMessage());
    }
}

4）运行后果

2.3.4 判断办法
1）源码 


public boolean isPresent() {return value != null;}
public void ifPresent(Consumer<? super T> consumer) {if (value != null)
        consumer.accept(value);
}
public T orElse(T other) {return value != null ? value : other;}   
public T orElseGet(Supplier<? extends T> other) {return value != null ? value : other.get();
}
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {if (value != null) {return value;} else {throw exceptionSupplier.get();
   }
}

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）测试代码 


public static void main(String[] args) {
    Integer value1 = null;
    Integer value2 = 1;
    Optional<Integer> optional1 = Optional.ofNullable(value1);
    Optional<Integer> optional2 = Optional.of(value2);
    try {if(optional1.isPresent()){System.out.println("optional1 的 isPresent 后果不为空");
        }else{System.out.println("optional1 的 isPresent 后果为空");
        }
    }catch (Exception e){System.out.println("optional1 的 isPresent 判空失败, 起因:"+e.getMessage());
    }
    try {if(optional2.isPresent()){System.out.println("optional2 的 isPresent 后果不为空");
        }else{System.out.println("optional2 的 isPresent 后果为空");
        }
    }catch (Exception e){System.out.println("optional2 的 isPresent 判空失败, 起因:"+e.getMessage());
    }
 
 
    optional1.ifPresent(t->{
        int i =t+1;
        System.out.println("optional1 解决后的值是"+i);
    });
    optional2.ifPresent(t->{
        int i =t+1;
        System.out.println("optional2 解决后的值是"+i);});
 
 
    Integer value3 = 2;
    Integer result = optional1.orElse(value3);
    System.out.println("optional1 执行 orElse 解决后的值是"+result);
 
 
    result = optional2.orElse(value3);
    System.out.println("optional2 执行 orElse 解决后的值是"+result);
 
 
    result = optional1.orElseGet(()-> new Integer(-1));
    System.out.println("optional1 执行 orElseGet 解决后的值是"+result);
 
 
    result = optional2.orElseGet(()-> new Integer(-1));
    System.out.println("optional2 执行 orElseGet 解决后的值是"+result);
    try {result = optional1.orElseThrow (()-> new RuntimeException("值是空的"));
    System.out.println("optional1 执行 orElseThrow 解决后的值是"+result);
    }catch (Exception e){System.out.println("optional1 的 orElseThrow 抛出异样:"+e.getMessage());
    }
    try {result = optional2.orElseThrow (()-> new RuntimeException("值是空的"));
    System.out.println("optional2 执行 orElseThrow 解决后的值是"+result);
    }catch (Exception e){System.out.println("optional2 的 orElseThrow 抛出异样:"+e.getMessage());

4）运行后果

2.3.5 过滤办法
1）源码 


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

2）办法阐明

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

3）测试代码 


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

4）运行后果

2.3.6 映射办法
1）源码 


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));
    }
}
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));
    }
}

2）办法阐明

  • map(Function mapper): 如果存在一个值，则对其利用提供的映射函数，如果后果非空，则返回形容后果的 Optional。否则返回一个空的 Optional。
  • flatMap(Function< T,Optional> mapper): 如果有值，则对其利用提供的可选映射函数，返回后果，否则返回空的可选函数。这个办法相似于 map(Function)，然而提供的映射器的后果曾经是一个可选的，如果调用，flatMap 不会用额定的可选的包装它。
  • 区别：map 会主动将 u 放到 optional 中，而 flatMap 则须要手动给 u 创立一个 optional

3）测试代码 


    public static void main(String[] args) {
        User user1 = null;
        User user2 = new User("user2 名字",19);
        Optional<User> optional1 = Optional.ofNullable(user1);
        Optional<User> optional2 = Optional.of(user2);
        System.out.println("=========map==========");
        System.out.println("optional1 的 map 前的值:"+optional1);
        Optional<String> result =optional1.map(t->t.getName());
        System.out.println("optional1 的 map 后的值:"+result);
 
 
        System.out.println("optional2 的 map 前的值:"+optional2);
        result =optional2.map(t->t.getName());
        System.out.println("optional2 的 map 后的值:"+result);
 
 
        System.out.println("===========flatMap========");
 
 
        System.out.println("optional1 的 flatMap 前的值:"+optional1);
        Optional<Integer> result2 =optional1.flatMap(t->Optional.ofNullable(t.getAge()));
        System.out.println("optional1 的 flatMap 后的值:"+result2);
 
 
        System.out.println("optional2 的 flatMap 前的值:"+optional2);
        result2 =optional2.flatMap(t->Optional.ofNullable(t.getAge()));
        System.out.println("optional2 的 flatMap 后的值:"+result2);
 
    }
public class User {
    String name;
    Integer age;
    public User(String name,Integer age){
        this.name = name;
        this.age=age;
    }
 
 
    public String getName() {return name;}
 
 
    public Integer getAge() {
        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 之前:


if(atest!=null){Btest btest =atest.getBtest();
    if(btest!=null){Ctest ctest = btest.getCtest();
      if (ctest != null) {name =ctest.getName();
      }
    }
}

应用 Optional 之后:


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

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

4 总结

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

作者：陈昌浩

退出移动版