正文
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
| 方法 | 描述 |
|---|---|
T orElse(T other) | 表示如果调用该方法的Optional对象的成员变量value不为null则返回value，否则返回other |
T orElseGet(Supplier<T> supplier) | 表示如果调用该方法的Optional对象的成员变量value不为null则返回value，否则用Supplier生成一个用于返回的T对象 |
T orElseThrow(Supplier<? extends X> exceptionSupplier) | 表示如果调用该方法的Optional对象的成员变量value不为null则返回value，否则用Supplier生成一个用于抛出的异常对象 |
我们看可以查看一下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 剩下的成员方法
| 方法 | 如果参数为null | 如果成员变量value为null | 如果成员变量value不为null |
|---|---|---|---|
Optional<T> filter(Predicate<? super T> predicate) | 抛出NullPointerException | 返回empty() | 如果predicate.test(T t)为true,返回当前对象，否则返回empty() |
Optional<U> map(Function<? super T, ? extends U> mapper) | 抛出NullPointerException | 返回empty() | 转换T为U，再返回Optional.ofNullable(U) |
Optional<U> flatMap(Function<? super T, Optional<U>> mapper) | 抛出NullPointerException | 返回empty() | 转换T为Optional<U>,转换后的对象如果为null,抛出NullPointerException |
测试代码
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);等等
