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