【Java 8】手把手教你 Optional 类

柔光的暖阳◎ 2023-10-03 15:56 54阅读 0赞

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