optional的使用

源码分析：

Optional 类是一个 final 类，说明 Optional 不能被继承。Optional 的构造函数是私有的，所以 Optional 是单例的对象。Optional 类提供一系列的方法，对 Java 程序逻辑的判断和优化处理

public final class Optional<T> {
    private static final Optional<?> EMPTY = new Optional<>();
    private final T value;
    private Optional() {
        this.value = null;
    }
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }
    public boolean isPresent() {
        return value != null;
    }
    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }
    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));
        }
    }
    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();
        }
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof Optional)) {
            return false;
        }
        Optional<?> other = (Optional<?>) obj;
        return Objects.equals(value, other.value);
    }
    @Override
    public int hashCode() {
        return Objects.hashCode(value);
    }
    @Override
    public String toString() {
        return value != null
            ? String.format("Optional[%s]", value)
            : "Optional.empty";
    }
}

#方法参考

• 1 private Optional() 无参构造，构造一个空 Optional

• 2 private Optional(T value) 根据传入的非空 value 构建 Optional

• 3 public static Optional empty() 返回一个空的 Optional，该实例的 value 为空

• 4 public static Optional of(T value) 根据传入的非空 value 构建 Optional，与 Optional(T value) 方法作用相同

• 5 public static Optional ofNullable(T value) 与 of(T value) 方法不同的是，ofNullable(T value) 允许你传入一个空的 value，当传入的是空值时其创建一个空 Optional，当传入的 value 非空时，与 of() 作用相同

• 6 public T get() 返回 Optional 的值，如果容器为空，则抛出 NoSuchElementException 异常

• 7 public boolean isPresent() 判断当家 Optional 是否已设置了值

• 8 public void ifPresent(Consumer<? super T> consumer) 判断当家 Optional 是否已设置了值，如果有值，则调用 Consumer 函数式接口进行处理

• 9 public Optional filter(Predicate<? super T> predicate) 如果设置了值，且满足 Predicate 的判断条件，则返回该 Optional，否则返回一个空的 Optional

• 10 public Optional map(Function<? super T, ? extends U> mapper) 如果 Optional 设置了 value，则调用 Function 对值进行处理，并返回包含处理后值的 Optional，否则返回空 Optional

• 11 public Optional flatMap(Function<? super T, Optional> mapper) 与 map() 方法类型，不同的是它的 mapper 结果已经是一个 Optional，不需要再对结果进行包装

• 12 public T orElse(T other) 如果 Optional 值不为空，则返回该值，否则返回 other

• 13 public T orElseGet(Supplier<? extends T> other) 如果 Optional 值不为空，则返回该值，否则根据 other 另外生成一个

• 14 public T orElseThrow(Supplier<? extends X> exceptionSupplier)throws X 如果 Optional 值不为空，则返回该值，否则通过 supplier 抛出一个异常

ofNullable 妙用：赋默认值

User user = new User();
user.setNickname(Optional.ofNullable(user.getNickname()).orElse("学生"));
user.setPassword(Optional.ofNullable(user.getPassword()).orElse("123456"));

isPresent

判断一个对象是否已经设置了值。如果 Optional 要处理的对象不为 null 就返回 true，否则就返回 false。

public static void main(String[] args) {
    User user = getUser(1);
    System.out.println(user);
}
public static User getUser(Integer userId) {
    User user = null;
    // 传统写法
    // if (user == null) {
    //     throw new RuntimeException("用户找不到!");
    // }
    // optional写法
    Optional<User> optional = Optional.ofNullable(user);
    if (!optional.isPresent()) {
        throw new RuntimeException("用户找不到!");
    }
    return user;
}

##orElseThrow()
判断一个对象是否为null，如果为 null 就抛出异常。实际上就是简化 if + throws 场景。

public static User getUser(Integer userId) {
    User user = null;
    // Optional<User> optional = Optional.ofNullable(user);
    // if (!optional.isPresent()) {
    //     throw new RuntimeException("用户找不到!");
    // }
    // 一步到位
    user = Optional.ofNullable(user)
        .orElseThrow(() -> new RuntimeException("用户找不到!"));
    return user;
}

orElse()

public static User getUser(Integer userId)  {
    User user = null;
    user = Optional.ofNullable(user).orElse(new User());
    return user;
}

orElseGet()

在开发中有些数据查询是有值的，有些是没有值的。如果要统计出错误访问的数据，抛异常和赋默认值都不是想要的，而是要定义行为，增加处理逻辑，这时就可以使用 orElseGet()。实际上就是简化 if + 逻辑处理场景。

user = Optional.ofNullable(user).orElseGet(()->{
    // 增加各种处理和逻辑
    return null;
});

Optional 实际应用

// 保存用户
@GetMapping("/getUser/{userid}")
public User getUser(@PathVariable("userId") Integer userId) {
    User user = userService.getById(userId);
    user = Optional.ofNullable(user).orElseThrow(() -> new RuntimeException("用户找不到!!") );
    return user;
}
// 保存用户 mybatis
@PostMapping("/saveUser")
public void saveUser(@RequestBody User user) {
    User user = userService.getById(user.getId());
    user = Optional.ofNullable(user).orElse(new User());
    if (!Optional.ofNullable(user.getId()).isPresent()) {
        user.setNickname(Optional.ofNullable(user.getNickname()).orElse("学生"));
        user.setPassword(Optional.ofNullable(user.getPassword()).orElse("123456"));
        userService.save(user);
    } else {
        userService.update(user);
    }
}

of 和 ofNullable 的区别

共同点：

两者的目标是一致的。都是创建 Optional 对象，给 value 成员变量赋值。

不同点：

of 传递 null 的时候会报空指针异常。因为 of 的底层在创建 Optional 对象时，如果 value 是 null 就就出现空指针异常。也就是说，of 只能处理非空对象。

Optional<String> fullName1 = Optional.of(null);
Optional<String> fullName2 = Optional.ofNullable(null);

 private Optional(T value) {
     this.value = Objects.requireNonNull(value);
 }

public static <T> T requireNonNull(T obj) {
    if (obj == null)
        throw new NullPointerException();
    return obj;
}

Optional 中 filter、map、flatmap 的认识

filter、map、flatmap 属于 Stream 流的中间方法，但 Optional 里的这些方法与 Stream 流无关。Optional 中主要是解决程序开发过程中集合为空的问题。

如果调用的是 Optional 的 filter 方法内部出现异常直接返回一个空的 Optional 对象。

如果调用的是 Stream 流的 filter 方法内部出现异常直接返回空指针异常。

List<User> users = null;
List<User> userList = Optional.ofNullable(users)
    .filter(user -> user.get(0).getId().equals(0))
    .orElse(new ArrayList<>());
System.out.println(userList); // []
List<User> collect = users.stream()
    .filter(user -> user.getId().equals(0))
    .collect(Collectors.toList());
System.out.println(collect); // java.lang.NullPointerException