(三)Java8 Optional 类

Optional 类主要解决的问题是臭名昭著的空指针异常(NullPointerException)。
本质上,这是一个包含有可选值的包装类,这意味着 Optional 类既可以含有对象也可以为空。

例如:

String isocode = user.getAddress().getCountry().getIsocode().toUpperCase();

在 Java 8 之前,任何访问对象方法或属性的调用都可能导致 NullPointerException
在这个小示例中,如果我们需要确保不触发异常,就得在访问每一个值之前对其进行明确地检查:


if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        Country country = address.getCountry();
        if (country != null) {
            String isocode = country.getIsocode();
            if (isocode != null) {
                isocode = isocode.toUpperCase();
            }
        }
    }
}

容易造成代码冗长难以维护。

API

序号 方法 & 描述
1 static Optional empty() 返回空的 Optional 实例。
2 boolean equals(Object obj) 判断其他对象是否等于 Optional。
3 Optional filter(Predicate<? super predicate) 如果值存在,并且这个值匹配给定的 predicate,返回一个Optional用以描述这个值,否则返回一个空的Optional。
4 Optional flatMap(Function<? super T,Optional> mapper) 如果值存在,返回基于Optional包含的映射方法的值,否则返回一个空的Optional。
5 T get() 如果在这个Optional中包含这个值,返回值,否则抛出异常:NoSuchElementException。
6 int hashCode() 返回存在值的哈希码,如果值不存在 返回 0。
7 void ifPresent(Consumer<? super T> consumer) 如果值存在则使用该值调用 consumer , 否则不做任何事情。
8 boolean isPresent() 如果值存在则方法会返回true,否则返回 false。
9 Optional map(Function<? super T,? extends U> mapper) 如果有值,则对其执行调用映射函数得到返回值。如果返回值不为 null,则创建包含映射返回值的Optional作为map方法返回值,否则返回空Optional。
10 static Optional of(T value) 返回一个指定非null值的Optional。
11 static Optional ofNullable(T value) 如果为非空,返回 Optional 描述的指定值,否则返回空的 Optional。
12 T orElse(T other) 如果存在该值,返回值, 否则返回 other。
13 T orElseGet(Supplier<? extends T> other) 如果存在该值,返回值, 否则触发 other,并返回 other 调用的结果。
14 T orElseThrow(Supplier<? extends X> exceptionSupplier) 如果存在该值,返回包含的值,否则抛出由 Supplier 继承的异常
15 String toString() 返回一个Optional的非空字符串,用来调试。

源码

  • static Optional empty():返回内容为空的Optional
    /**
     * Common instance for {@code empty()}.
     */
    private static final Optional<?> EMPTY = new Optional<>();

    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
  • boolean equals(Object obj):重写Object的equals方法,obj必须是Optional类型,然后判断两个Optional容器中的值进行Objects.equals判断。
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (!(obj instanceof Optional)) {
            return false;
        }

        Optional<?> other = (Optional<?>) obj;
        return Objects.equals(value, other.value);
    }

    //Objects.equals(Object a, Object b)
    public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
    }
  • Optional filter(Predicate<? super predicate):如果容器中value值为null返回当前Optional(即值为null的Optional),若test()方法为true返回当前value不为空的Optional,为false返回EMPTY = new Optional<>()(值为空的Optional)
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }

    public boolean isPresent() {
        return value != null;
    }

  • Optional flatMap(Function<? super T, Optional> mapper): 提取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));
        }
    }

  • T get():若容器value值不为null则返回value值,否则抛出异常
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }
  • void ifPresent(Consumer<? super T> consumer):若容器中value不为null则进行accept(value)自定义操作。
    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }
  • boolean isPresent():容器中value值是否为null
    public boolean isPresent() {
        return value != null;
    }
  • Optional map(Function<? super T, ? extends U> mapper):
    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));
        }
    }
  • static Optional of(T value):创建一个新的Optional。value参数不能为null,否则抛出异常
     public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
  • static Optional ofNullable(T value):创建一个新的Optional。value参数可以为null,为null时返回EMPTY = new Optional<>()值为空的Optional
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }
  • T orElse(T other):容器中value值为null则返回默认的 other值
    public T orElse(T other) {
        return value != null ? value : other;
    }
  • T orElseGet(Supplier<? extends T> other):容器中value值为null则返回默认的 other.get()值
    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

    //Supplier get()
    T get();
  • T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X:容器中value值为null则抛出指定异常
    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

参考:https://blog.csdn.net/xhd731568849/java/article/details/79532959

上一篇:C++笔记 ——在模板类中重载操作符


下一篇:如何查看.net framework 版本