Java中的Optional类详细解读

//T 为元素数据类型
public final class Optional<T>

//空容器
private static final Optional<?> EMPTY = new Optional<>();
//value 存储容器内唯一元素
private final T value;

//无参构造方法：this.value = null
private Optional()
//有参构造方法(value不允许为空)：this.value = Objects.requireNonNull(value)
private Optional(T value)

//创建空容器：return (Optional<T>) EMPTY
public static<T> Optional<T> empty()
//创建容器(value不允许为空)：return new Optional<>(value)
public static <T> Optional<T> of(T value)
//创建容器(value允许为空)：return value == null ? empty() : of(value)
public static <T> Optional<T> ofNullable(T value)

//判断容器是否为空：return value != null
public boolean isPresent()
//判断容器是否为空，若不为空，消费元素
public void ifPresent(Consumer<? super T> consumer) {
	if (value != null)
		consumer.accept(value);
}

Optional<User> op = Optional.of(new User("张三", 20));
op.ifPresent(user -> System.out.println(user));
//op.ifPresent(System.out::println);

//获取容器中唯一元素：return value
public T get()
//获取容器唯一元素，若为空，返回指定值：return value != null ? value : other
public T orElse(T other)
//获取容器唯一元素，若为空，返回供应者(Supplier)提供的元素
public T orElseGet(Supplier<? extends T> other) {
	return value != null ? value : other.get();
}

Optional<User> op = Optional.ofNullable(null);
User user = op.orElseGet(() -> new User("张三", 20));

//过滤不符合断言(Predicate)的元素
public Optional<T> filter(Predicate<? super T> predicate) {
	Objects.requireNonNull(predicate);
	if (!isPresent())
		return this;
	else
		return predicate.test(value) ? this : empty();
}

Optional<User> op = Optional.of(new User("张三", 20));
Optional<User> op2 = op.filter(user -> user.age > 18);

//将 T 类型元素映射为 U 类型元素
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));
	}
}

Optional<String> op = Optional.of(new String("12345"));
Optional<Integer> op2 = op.map(str -> {
	try {
		return Integer.parseInt(str);
	} catch (Exception e) {
		return -1;
	}
});