【Java 8】手把手教你 Optional 类
1. 什么是 Optional
Java 8 中引入的一个很有趣的特性是 Optional 类。Optional 类主要解决的问题是空指针异常（NullPointerException）。本质上，它是一个包含有可选值的包装类，这意味着 Optional 类既可以含有对象也可以为空。如果值存在则 isPresent() 方法会返回 true，调用 get() 方法会返回该对象
2. 创建 Optional 实例
查看 Optional 类源码:
public final class Optional<T> {
private static final Optional<?> EMPTY = new Optional<>();
private final T value;
private Optional() {
this.value = null;
}
}
Optional 被 final 修饰；它是个泛型类
创建 Optional 实例有三种：of()、emptl()、ofNullable()
2.1 of()
of()：把指定的值（可以为任意对象）封装为 Optional 对象
public static <T> Optional<T> of(T value) {
return new Optional<>(value);
}
用法：
public static void main(String[] args) {
// 创建一个字符串值为 Java 的 Optional 实例
Optional<String> stringOptional = Optional.of("Java");
// 创建一个为 User 对象的 Optional 实例
User user = new User();
user.setName("zzc");
user.setAge(23);
Optional<User> userOptional = Optional.of(user);
}
如果传入 null，则会报空指针
public static void main(String[] args) {
Optional<User> optional = Optional.of(null);
}
这样，我们并没有完全摆脱 NullPointerException。因此，你应该明确对象不为 null 的时候使用 of() 方法
2.2 empty()
empty() ：创建一个空的Optional对象
public static<T> Optional<T> empty() {
Optional<T> t = (Optional<T>) EMPTY;
return t;
}
返回一个空的 Optional 对象，这个Optional 对象中没有值。也就是说 Optional 里面包装的对象为 null。
可通过将==与Option.empty() 返回的实例进行比较来避免测试对象是否为空。但不能保证它是一个单例，所以使用 isPresent() 替代
String name = null;
Optional<String> nameOpt = Optional.ofNullable(name);
Optional<String> emptyOpt = Optional.empty();
System.out.println(nameOpt == emptyOpt);
所以使用 Optional.empty() 方法来代替 null，可以避免抛出 NullPointerException 异常
2.3 ofNullable()
ofNullable()：把指定的值封装为 Optional 对象，如果指定的值为null，则创建一个空的 Optional 对象
public static <T> Optional<T> ofNullable(T value) {
return value == null ? empty() : of(value);
}
用法：
public class Test {
public static void main(String[] args) {
// 创建一个字符串值为 Java 的 Optional 实例
Optional<String> stringOptional = Optional.ofNullable("Java");
// 创建一个为 User 对象的 Optional 实例
User user = new User();
user.setName("zzc");
user.setAge(23);
Optional<User> userOptional = Optional.ofNullable(user);
// 即使传入 null，也不报空指针
Optional<Object> o = Optional.ofNullable(null);
}
}
如果对象即可能是 null 也可能是非 null，你就应该使用 ofNullable() 方法
3. 访问 Optional 对象的值
从 Optional 实例中取回实际值对象的方法之一是使用 get() 方法：
注意：使用一个空的 Optional 实例调用 get() 方法时，会抛异常 NoSuchElementException，如下：
public static void main(String[] args) {
Optional<Object> empty = Optional.empty();
System.out.println(empty.get());
}
使用 ofNullable() 方法：
public static void main(String[] args) {
User user = new User("zzc", 23);
Optional<User> userOptional = Optional.ofNullable(user);
System.out.println(userOptional.get());
}
当 ofNullable() 方法传入 null 时，调用 get() 方法也会抛异常 NoSuchElementException
public static void main(String[] args)
Optional<Object> empty = Optional.ofNullable(null);
System.out.println(empty.get());
}
所以，为了避免异常，首先验证是否有值：
public static void main(String[] args) {
User user = new User("zzc", 23);
Optional<User> userOptional = Optional.ofNullable(user);
// 判断是否有值
if (userOptional.isPresent()) {
System.out.println(userOptional.get());
}
}
好像看着代码是优美了点 —— 但是事实上这与之前判断 null 值的代码没有本质的区别，反而用 Optional 去封装 value，增加了代码量。所以，这里我们使用 Optional 中另一个方法 ifPresent()
ifPresent()
public void ifPresent(Consumer<? super T> consumer) {
if (value != null)
consumer.accept(value);
}
如果 Optional 中有值，则对该值调用 consumer.accept，即：执行传入的 lambda 表达式，否则什么也不做。如下：
public static void main(String[] args) {
User user = new User("zzc", 23);
Optional<User> userOptional = Optional.ofNullable(user);
userOptional.ifPresent(u -> System.out.println(u.getName()));
}
4. 返回默认值
Optional 类提供了 API 用以返回对象值，或者在对象为空的时候返回默认值。
4.1 orElse()
orElse()：它的工作方式非常直接，如果有值则返回该值，否则返回传递给它的参数值：
public static void main(String[] args) {
User user = new User("zzc", 23);
User user2 = null;
Optional<User> userOptional = Optional.ofNullable(user);
User result = Optional.ofNullable(user2).orElse(user);
System.out.println(result.getName());
}
这里 user2 对象是空的，所以返回了作为默认值的 user；如果对象的初始值不是 null，那么默认值会被忽略
4.2 orElseGet()
orElseGet()：这个方法会在有值的时候返回值；如果没有值，它会执行作为参数传入的 Supplier(供应者) 函数式接口，并将返回其执行结果
public static void main(String[] args) {
User user = new User("zzc", 23);
User user2 = null;
User result = Optional.ofNullable(user2).orElseGet(() -> user);
System.out.println(result.getName());
}
这两者的区别：
我们创建一些示例来突出二者行为上的异同。
对象为空时他们的行为：
public static void main(String[] args) {
User user = null;
User user1 = Optional.ofNullable(user).orElse(getUser());
User user2 = Optional.ofNullable(user).orElseGet(() -> getUser());
}
private static User getUser() {
System.out.println("=======GET-USER=======");
return new User("zzc", 23);
}
}
上面的代码中，两种方法都调用了 getUser() 方法，这个方法会记录一个消息并返回 User 对象。
由此可见，当对象为空而返回默认对象时，行为并无差异
接下来看一个类似的示例，但这里 Optional 不为空：
public static void main(String[] args) {
User user = new User("gg", 20);
User user1 = Optional.ofNullable(user).orElse(getUser());
User user2 = Optional.ofNullable(user).orElseGet(() -> getUser());
}
private static User getUser() {
System.out.println("=======GET-USER=======");
return new User("zzc", 23);
}
这个示例中，两个 Optional 对象都包含非空值，两个方法都会返回对应的非空值。不过，orElse() 方法仍然创建了 User 对象。与之相反，orElseGet() 方法不创建 User 对象。
在执行较密集的调用时，比如调用 Web 服务或数据查询，这个差异会对性能产生重大影响。
5. 返回异常
5.1 orElseThrow()
orElseThrow()：它会在对象为空的时候抛出异常，而不是返回备选的值
public static void main(String[] args) {
User user = new User("zzc", 23);
User user2 = null;
Optional.ofNullable(user2).orElseThrow(RuntimeException::new);
}
6. 转换值
6.1 map()
如果创建的Optional中的值存在，对该值执行提供的 Function 函数调用
public static void main(String[] args) {
User user = new User("zzc", 23);
String name = Optional.ofNullable(user).map(u -> u.getName()).orElse("Boy");
System.out.println(name);
}
6.2 flatMap()
如果创建的Optional中的值存在，就对该值执行提供的Function函数调用，返回一个Optional类型的值，否则就返回一个空的Optional对象.flatMap与map（Funtion）方法类似，区别在于flatMap中的mapper返回值必须是Optional，map方法的mapping函数返回值可以是任何类型T。调用结束时，flatMap不会对结果用Optional封装。
public static void main(String[] args) {
String name = Optional.ofNullable(user).flatMap(u -> Optional.of("Girl")).orElse("Boy");
System.out.println(name);
}
7. 过滤
7.1 filter()
filter() 接受一个 Predicate 参数，返回测试结果为 true 的值。如果测试结果为 false，会返回一个空的 Optional。
public static void main(String[] args) {
User user = new User("zzc", 23);
Optional<User> userOptional = Optional.ofNullable(user).filter(u -> null != u.getAge() && u.getAge() > 20);
System.out.println(userOptional.isPresent());
}
8.Optional 类的链式方法
为了更充分的使用 Optional，你可以链接组合其大部分方法，因为它们都返回相同类似的对象。
public static void main(String[] args) {
User user = new User("zzc", 23);
String string = Optional.ofNullable(user)
.flatMap(User::getAddress)
.map(Address::getName)
.orElse("default");
System.out.println(string);
}
结果现在的代码看起来比之前采用条件分支的冗长代码简洁多了
9. 应用 Optional
在使用 Optional 的时候需要考虑一些事情，以决定什么时候怎样使用它。
重要的一点是 Optional 不是 Serializable。因此，它不应该用作类的字段。
情景一：
Optional 类有一个非常有用的用例，就是将其与流或其它返回 Optional 的方法结合，以构建流畅的API。
我们来看一个示例，使用 Stream 返回 Optional 对象的 findFirst() 方法：
public static void main(String[] args) {
List<User> users = new ArrayList<>();
User user = users.stream().findFirst().orElse(new User("default", "1234"));
}
情景二：
修改前：
public String getClientIp(HttpServletRequest request) {
String clientId = request.getHeader("X-Forwarded-For");
if (null != clientId) {
return clientId;
}
clientId = request.getHeader("X-Real-IP");
return clientId;
}
修改后：
public String getClientIp2(HttpServletRequest request) {
String clientId = request.getHeader("X-Forwarded-For");
return Optional.ofNullable(clientId).orElseGet(() -> request.getHeader("X-Real-IP"));
}
情景三：
修改前：
if (null != user) {
doSomenthing();
}
修改后：
Optional.ofNullable(user).ifPresent(u -> doSomenthing())
情景四：
修改前：
if (null != user) {
return user.getName();
}
throw new RuntimeException("No User")
修改后：
public String getName(User user) {
return Optional.ofNullable(user).map(user -> user.getName).orElseThrow(() -> new RuntionException("No User"))
}
public User getName(User user) {
return Optional.ofNullable(user).filter(u -> "zzc".equals(u.getName())).orElseGet(() -> { User u = new User(); u.setName("zzc"; return u;)})
}
情景五：
修改前：
if (null != user) {
List list = user.getChild();
if (null != list) {
return list;
}
return Collections.emptyList();
}
修改后：
public List<String> listChilds() {
return Optional.ofNullable(user).map(User::getChild).orElse(Collections.emptyList());
}