Java 8新特性 - (15)Optional类
相关文章： Java 9对Optional类的改进
Java 8中引入了Optional类来解决 NullPointerException 与繁琐的 null 检查。它是一个封装值的类，用于保存类型为T的值，从本质上说它就是一个容器。
变量存在时，Optional类只是对类简单封装。变量不存在时，缺失的值会被建模成一个“空” 的Optional对象，由方法Optional.empty()返回。那null和 Optional.empty()的区别在哪呢？从语义上，可以把它们当作一回事儿，但是实际中它们之间的差别非常大：如果尝试解引用一个null， 一定会触发NullPointerException，而使用Optional.empty()就完全没事，它是 Optional类的一个有效对象。
创建 Optional 对象
空Optional
可以通过静态工厂方法 Optional.empty，创建一个空的 Optional 对象：
Optional<Car> option = Optional.empty();因为 empty() 本身代表的就是空对象，所以调用 get 方法会抛出 NoSuchElementException 异常。
非空Optional
可以使用静态工厂方法 Optional.of，依据一个非空值创建一个 Optional 对象：
Optional<Car> optional = Optional.of(car);如果 car 是一个 null，这段代码会立即抛出一个 NullPointerException，而不是等到试图访问car的属性值时才返回一个错误。
可为null的Optional
使用静态工厂方法 Optional.ofNullable，可以创建一个允许 null 值的 Optional 对象：
Optional<Car> optional = Optional.ofNullable(car);如果 car 是 null，那么得到的 Optional 对象就是个空对象。我们可以查看一下它的实现原理：
public static <T> Optional<T> ofNullable(T value) {
return value == null ? empty() : of(value);
}根据它的实现方式，传入的值是空值时，会返回 Optional.empty() 空对象。这有利于封装那些可能为 null 的值。例如，有一个 Map<String, Object> 实例，访问 key 索引时，如果没有与 key 关联的值，则会返回一个 null。因此，可以使用 Optional.ofNullable 方法封装返回值：
Optional<Object> value = Optional.ofNullable(map.get("key"));访问Optional对象的值
isPresent & get
在 Optional 类中，isPresent 方法对 Optional 实例进行判断，是否包含值，如果存在值，就返回 true，否则返回 false；与之相对的是 isEmpty 方法Optional 类中还有 get 方法，它是用来获取 Optional 实例中的值。
Optional<String> optional = Optional.of("is present");
if (optional.isPresent()) {
System.out.println("the value is " + optional.get());
}isPresent 与 get 一般组合使用来避免 NullPointerException：
public boolean isPresent() {
return value != null;
}
public T get() {
if (value == null) {
throw new NoSuchElementException("No value present");
}
return value;
}从源码中可看出，get 方法在取值时，要进行判空操作，如果不使用 isPresent 方法，可能会出现空指针异常。但是这种方式和在代码中if(null != value) 没有区别，因此要尽量避免使用该组合
ifPresent
除了 isPresent 的简洁方法，Optional 还提供了接收函数式参数的接口 ifPresent：
public void ifPresent(Consumer<? super T> action) {
if (value != null) {
action.accept(value);
}
}该方法会接收一个消费型函数。如果 Optional 实例中的值不为空，则调用 Consumer 的 accept 方法对 value 进行消费，若为空则不做处理。上面的例子可以使用 ifPresent 重写：
Optional<String> optional = Optional.of("is present");
optional.isPresent((val) -> System.out.println("the value is " + val));返回默认值
orElse
还可以使用 orElse 方法读取 Optional 中的值。
public T orElse(T other) {
return value != null ? value : other;
}使用这种方式可以定义一个默认值，这种方式当遭遇 Optional 中的变量为空时，默认值会作为该方法的返回值。
String optGet = null;
String orElse = Optional.ofNullable(optGet).orElse("Default");orElseGet
还可以使用另一种方式 orElseGet：
public T orElseGet(Supplier<? extends T> supplier) {
return value != null ? value : supplier.get();
}该方法与 orElse 的区别就是值不存在时，调用实现 Supplier 接口的方法或Lambda表达式来返回默认值。
String optGet = null;
String orElse = Optional.ofNullable(optGet).orElse(() -> "Default");返回异常
orElseThrow
orElseThrow方法是在有值时返回其值，无值的时候会抛出由 Supplier 创建的异常。我们看一下它的实现原理：
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
if (value != null) {
return value;
} else {
throw exceptionSupplier.get();
}
}可以看到，它会传入一个Lambda表达式或方法，如果值不存在来抛出异常：
class NoValueException extends RuntimeException {
public NoValueException() {
super();
}
@Override
public String getMessage() {
return "No value present in the Optional instance";
}
}
public static Integer orElseThrow() {
return (Integer) Optional.empty().orElseThrow(NoValueException::new);
}
public static void main(String[] args) {
orElseThrow();
}orElseThrow 与 orElseGet 的区别就是一个在无值的时候抛出异常，一个在无值的时候使用Lambda表达式来实现默认值。
orElseThrow 只是在无值的时候抛出异常，那本身会抛出异常的方法呢？
现在拿 Integer.parseInt(String) 做个例子：
public static Integer toInt(String s) {
try {
// 如果String能转换为对应的Integer，将其封装在Optional对象中返回
return Integer.parseInt(s);
} catch (NumberFormatException e) {
return null; // 返回null 或者抛出异常
}
}在将 String 转换为 int 时，如果无法解析到对应的整型，该方法会抛出 NumberFormatException 异常。我们在该方法中使用 try/catch 语句捕获了该异常，不能使用 if 条件判断来控制一个变量的值是否为空。
这时，可以使用 Optional 类，来对无法转换的 String 时返回的非法值进行建模，因此可以对上述方法进行改进：
public static Optional<Integer> toInt(String s) {
try {
// 如果String能转换为对应的Integer，将其封装在Optional对象中返回
return Optional.of(Integer.parseInt(s));
} catch (NumberFormatException e) {
return Optional.empty(); // 否则返回一个空的 Optional 对象
}
}这种返回 Optional 的方式适用很多方法，我们只需要获取被 Optional 包装的值的实例即可。
对值进行转换
map
Optional 提供了 map 方法用于从对象中提取信息，它的工作原理如下：
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));
}
}map 操作会将提供的函数应用于流的每个元素。可以把 Optional 对象看成一种特殊的集合数据，它至多包含一个元素。如果 Optional 包含一个值，那通过实现了 Function 接口的 Lambda 表达式对值进行转换。map 方法示例如下：
class Car {
private String name;
private String type;
//...省略getter与setter...
}
Optional<Car> optional = Optional.ofNullable(car);
Optional<String> name = optional.map(Car::getName);flatMap
看下面这段代码，它想使用 map 方法来从被 Optional 类包装的 Person 类中获取 Car 的名称：
class Person {
private Optional<Car> car;
public Person(Car car) {
this.car = Optional.of(car);
}
//...省略getter与setter...
}
Person person = new Person(new Car());
Optional<Person> optPerson = Optional.of(person);
Optional<String> name = optPerson.map(Person::getCar).map(Car::getName);不幸的是，这段代码无法通过编译。为什么呢？optPerson 是 Optional
这里，需要使用 flatMap 方法。该方法接受一个函数作为参数，这个函数的返回值是另一个流。
public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
Objects.requireNonNull(mapper);
if (!isPresent()) {
return empty();
} else {
@SuppressWarnings("unchecked")
Optional<U> r = (Optional<U>) mapper.apply(value);
return Objects.requireNonNull(r);
}
}参照 map 函数，使用 flatMap 重写上述的示例：
Optional<String> name = optPerson.flatMap(Person::getCar).map(Car::getName);filter
有时候我们需要对 Optional 中的值进行过滤，获得我们需要的结果，我们就可以使用 filter 方法：
public Optional<T> filter(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate);
if (!isPresent())
return this;
else
return predicate.test(value) ? this : empty();
}该方法接受 Predicate 谓词作为参数。如果 Optional 对象的值存在，并且符合谓词的条件，即操作结果为true，filter 方法不做任何改变并返回其值；否则就将该值过滤掉并返回一个空的 Optional 对象。
Optional<String> optionalS = Optional.of("13846901234");
optionalS = optionalS.filter(s -> s.contains("138"));
/**
* 上述 `filter` 方法满足条件可以返回同一个Optional，否则返回空Optional
*/注意事项
- Optional的包装和访问都有成本，因此不适用于一些特别注重性能和内存的场景。
- 不要将null赋给Optional，应赋以Optional.empty()。
- 避免调用isPresent()和get()方法，而应使用ifPresent()、orElse()、 orElseGet()和orElseThrow()。举一isPresent()用法示例：
private static boolean isIntegerNumber(String number) {
number = number.trim();
String intNumRegex = "\\-{0,1}\\d+";
if (number.matches(intNumRegex)) {
return true;
} else {
return false;
}
}
// Optional写法1（含NPE修复及正则表达式优化）
private static boolean isIntegerNumber1(String number) {
return Optional.ofNullable(number)
.map(String::trim)
.filter(n -> n.matches("-?\\d+"))
.isPresent();
}
// Optional写法2（含NPE修复及正则表达式优化，不用isPresent）
private static boolean isIntegerNumber2(String number) {
return Optional.ofNullable(number)
.map(String::trim)
.map(n -> n.matches("-?\\d+"))
.orElse(false);
}- Optional应该只用处理返回值，而不应作为类的字段(Optional类型不可被序列化)或方法(包括constructor)的参数。
- 不要为了链式方法而使用Optional，尤其是在仅仅获取一个值时。例如：
// good
return variable == null ? "blablabla" : variable;
// bad
return Optional.ofNullable(variable).orElse("blablabla");
// bad
Optional.ofNullable(someVariable).ifPresent(this::blablabla)- 滥用Optional不仅影响性能，可读性也不高。应尽可能避免使用null引用。
- 避免使用Optional返回空的集合或数组，而应返回Collections.emptyList()、emptyMap()、emptySet()或new Type[0]。注意不要返回null，以便调用者可以省去繁琐的null检查。
- 避免在集合中使用Optional，应使用getOrDefault()或computeIfAbsent()等集合方法。
- 针对基本类型，使用对应的OptionalInt、OptionalLong和OptionalDouble类。
- 切忌过度使用Optional，否则可能使代码难以阅读和维护。
- 常见的问题是Lambda表达式过长，例如：
private Set<String> queryValidUsers() {
Set<String> userInfo = new HashSet<String>(10);
Optional.ofNullable(toJSonObject(getJsonStrFromSomewhere()))
.map(cur -> cur.optJSONArray("data"))
.map(cur -> { // 大段代码割裂了"思路"
for (int i = 0; i < cur.length(); i++) {
JSONArray users = cur.optJSONObject(i).optJSONArray("users");
if (null == users || 0 == users.length()) {
continue;
}
for (int j = 0; j < users.length(); j++) {
JSONObject userObj = users.optJSONObject(j);
if (!userObj.optBoolean("stopUse")) { // userObj可能为null!
userInfo.add(userObj.optString("userId"));
}
}
}
return userInfo;
});
return userInfo;
}通过简单的抽取方法，可读性得到很大提高：
private Set<String> queryValidUsers() {
return Optional.ofNullable(toJSonObject(getJsonStrFromSomewhere()))
.map(cur -> cur.optJSONArray("data"))
.map(this::collectNonStopUsers)
.orElse(Collections.emptySet());
}
private Set<String> collectNonStopUsers(JSONArray dataArray) {
Set<String> userInfo = new HashSet<String>(10);
for (int i = 0; i < dataArray.length(); i++) {
JSONArray users = dataArray.optJSONObject(i).optJSONArray("users");
Optional.ofNullable(users).ifPresent(cur -> {
for (int j = 0; j < cur.length(); j++) {
Optional.ofNullable(cur.optJSONObject(j))
.filter(user -> !user.optBoolean("stopUse"))
.ifPresent(user -> userInfo.add(user.optString("userId")));
}
});
}
return userInfo;
}参考：