JDK1.8新特性之Optional

概念

Optional 是JDK1.8中出现的一个容器类，代表一个值存在或者不存在。原来使用null表示一个值不存在，现在Optional可以更好的表达这个概念。并且可以避免空指针异常。

场景分析

需求：假如我们要取一个男人心中的女神的名字。

假如不使用Optional来实现

男人Man.java

public class Man {

    private Goddess goddess;

    public Goddess getGoddess() {
        return goddess;
    }

    public void setGoddess(Goddess goddess) {
        this.goddess = goddess;
    }
}    

女神Goddess.java

public class Goddess {

    private String name;

    public Goddess(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

测试类Main.java

public class Main {

    public static void main(String[] args) {
        Man man = new Man();
        System.out.println(getGoddessOfMan(man));
    }

    // 获取男人心中的女神
    public static String getGoddessOfMan(Man man) {
        return man.getGoddess().getName();
    }
}

出现异常：

如果单看报错内容，我们可以知道是man.getGoddess().getName();这条语句发生了空指针异常，但是我们还需要进一步定位才能知道究竟是man为null，还是goddess为null？

我们可以改写测试类代码来避免这个异常

// 获取男人心中的女神
public static String getGoddessOfMan(Man man) {
    if (man == null || man.getGoddess() == null) {
        return "";
    }
    return man.getGoddess().getName();
}

假如用上Optional来实现

改写Man.java

public class Man {

    private Optional<Goddess> goddess = Optional.empty();

    public Optional<Goddess> getGoddess() {
        return goddess;
    }

    public void setGoddess(Optional<Goddess> goddess) {
        this.goddess = goddess;
    }
}

Goddess.java不改写

改写测试类Main.java

public class Main {

    public static void main(String[] args) {
        Man man = new Man();
        System.out.println(getGoddessOfMan(Optional.ofNullable(man)));
        man = null;
        System.out.println(getGoddessOfMan(Optional.ofNullable(man)));
    }

    // 获取男人心中的女神
    public static String getGoddessOfMan(Optional<Man> optionalMan) {
        return optionalMan.orElse(new Man()).getGoddess().orElse(new Goddess("蒙娜丽莎")).getName();
    }
}

控制台中打印出

蒙娜丽莎
蒙娜丽莎

其实，看上去也没有省几行代码嘛？那么我们接着往下分析Optional类。

分析Optional容器类

1.Optional的创建方法

Optional的核心且唯一的属性就是T value。
另外，因为Optional的构造器都被私有化了，所以只能通过静态方法创建Optional对象。

1.1 静态创建方法of(T t) --- 不允许参数为null

测试代码如下，我们尝试传一个参数null给of（T t）方法，结果发生了NullPointerException

// of方法会判断参数是否为null，如果为null，会报空指针异常
Optional<Goddess> op = Optional.of(null);

我们深入java.util.Optional的源代码

public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
}

private Optional(T value) {
   this.value = Objects.requireNonNull(value);
}

再追踪到java.util.Objects的源代码

public static <T> T requireNonNull(T obj) {
    if (obj == null)
        throw new NullPointerException();
    return obj;
}

1.2 静态创建方法empty() --- 创建一个value=null的Optional容器对象

再看java.util.Optional中empty()，返回一个成员变量value为null的Optional容器对象

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

public static<T> Optional<T> empty() {
    @SuppressWarnings("unchecked")
    Optional<T> t = (Optional<T>) EMPTY;
    return t;
}

1.3 静态创建方法ofNullable(T t) --- 允许参数为null

仍然看java.util.Optional的源代码，ofNullable表示可以接受null，并使用empty()返回。也接受参数value不为null，使用of(T t)返回。

public static <T> Optional<T> ofNullable(T value) {
    return value == null ? empty() : of(value);
}

2.Optional的判断和获取 --- 先使用isPresent()判断，再使用get()获取

测试代码如下

import java.util.Optional;

public class OptionalTest {

    public static void main(String[] args) {
        Optional<Goddess> op = Optional.of(new Goddess("蒙娜丽莎"));
        if (op.isPresent()) {
            System.out.println(op.get().getName());
        }

        Optional<Goddess> empty = Optional.ofNullable(null);
        // 先通过isPresent()判断，再使用get()来避免直接使用empty.get().getName()可能带来NoSuchElementException异常
        // if (empty.isPresent()) {
            System.out.println(empty.get().getName());
        // }
    }
}

控制台输出如下

蒙娜丽莎
Exception in thread "main" java.util.NoSuchElementException: No value present
at java.util.Optional.get(Optional.java:135)
at optional.OptionalTest.main(OptionalTest.java:15)

从控制台输出我们可以知道，在使用get()方法之前，最好先用isPresent()判断Optional中的成员变量value值是否存在。

3.把判断代码放在Optional类内的方法

3.2 orElse

我们看可以查看一下java.util.Optional源码

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

3.3 剩下的成员方法

测试代码

import java.util.Optional;

public class OptionalTest {

    public static void main(String[] args) {
        Optional<Goddess> op = Optional.of(new Goddess("蒙娜丽莎"));
        Optional<Goddess> nullOp = Optional.ofNullable(null);
        // 如果女神名称不为null,filter返回op,否则返回empty()
        System.out.println(op.filter(goddess->goddess.getName() != null).isPresent());
        System.out.println(nullOp.filter(goddess->goddess.getName() != null).isPresent());
        // 映射返回女神名称
        System.out.println(op.map(Goddess::getName).get());
        System.out.println(nullOp.map(Goddess::getName).isPresent());
        // 映射返回装有女神名称的Optional容器对象
        System.out.println(op.flatMap(goddess->Optional.ofNullable(goddess.getName())).get());
        System.out.println(nullOp.flatMap(goddess->Optional.ofNullable(goddess.getName())).isPresent());
    }
}

控制台输出如下：

true
false
蒙娜丽莎
false
蒙娜丽莎
false

再来看一下java.util.Optional源码

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

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

结语：回到最初的需求

假如我们扩展一下我们的需求

定义一个方法，获取男人心中的女神，要求男人不存在时抛出异常，如果男人存在，但是这个男人没有女神，那么给一个默认的女神名字-蒙娜丽莎

import java.util.Optional;

public class GetGoddessOfMan {

    public static void main(String[] args) {
        Man man = new Man();
        System.out.println(getGoddessOfMan(Optional.ofNullable(man)));
        man = null;
        System.out.println(getGoddessOfMan(Optional.ofNullable(man)));
    }

    // 获取男人心中的女神
    public static String getGoddessOfMan(Optional<Man> optionalMan) {
        return optionalMan.orElseThrow(NullPointerException::new).getGoddess().orElse(new Goddess("蒙娜丽莎")).getName();
    }
}

这里就比较简洁了，一句话就反映出了需求，且更接近自然语言。如果要用非Optional实现,代码类似下面这种

// 获取男人心中的女神
public static String getGoddessOfMan(Man man) {
    Objects.requireNonNull(man);
    Goddess goddess = man.getGoddess() == null ? new Goddess("蒙娜丽莎") : man.getGoddess();
    return goddess.getName();
}

不过很多小伙伴还是会觉得这个写法看上去有些奇怪。在其他JDK1.8的新特性中，比如Stream流中也有返回Optional<T>的函数，比如Optional<T> findFirst();,Optional<T> findAny();,Optional<T> max(Comparator<? super T> comparator), Optional<T> min(Comparator<? super T> comparator);等等

原文地址：https://www.cnblogs.com/zaid/p/12001384.html