您好,欢迎访问代理记账网站
  • 价格透明
  • 信息保密
  • 进度掌控
  • 售后无忧

【Java】Optional<T>类

/**
 * A container object which may or may not contain a null value.
 *
 * @param <T> the type of value
 * @since 1.8
 */
public final class Optional<T> {
	/**
	 * value 
	 */
	private final T value;

	/**
	 * 空的Optional<T>,value为null
	 */
    private static final Optional<?> EMPTY = new Optional<>(null);

	/**
	 * 私有的构造方法
     */
	private Optional(T value) {
        this.value = value;
    }

	/**
	 * 返回空的Optional<T>,value为null
	 */
    public static<T> Optional<T> empty() {
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

    /**
     * 创建Optional<T>
     * 如果value为null,那么抛出NullPointerException
     */
    public static <T> Optional<T> of(T value) {
        return new Optional<>(Objects.requireNonNull(value));
    }

    /**
     * 创建Optional<T>
     * 如果value为null,那么返回空的Optional<T>,value为null
     */
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? (Optional<T>) EMPTY : new Optional<>(value);
    }

    /**
     * 获取value,如果value为null,那么抛出NoSuchElementException
     */
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

    /**
     * 判断value是否为null,value不为null,那么返回true
     */
    public boolean isPresent() {
        return value != null;
    }

    /**
     * 判断value是否为null,value为null,那么返回true
     */
    public boolean isEmpty() {
        return value == null;
    }

    /**
     * 如果value不为null,那么执行Consumer实现类的accept(T value)方法
     */
    public void ifPresent(Consumer<? super T> action) {
        if (value != null) {
            action.accept(value);
        }
    }

    /**
     * 如果value不为null,那么执行Consumer实现类的accept(T value)方法
	 * 如果value为null,那么执行Runnable实现类的run()方法
     */
    public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
        if (value != null) {
            action.accept(value);
        } else {
            emptyAction.run();
        }
    }

    /**
     * 如果value不为null,并且使Predicate实现类的test(T value)方法返回true,那么返回当前value不为null的Optional<T>
	 * 如果value不为null,并且使Predicate实现类的test(T value)方法返回false,那么返回空的的Optional<T>
	 * 如果value为null,那么返回当前value为null的Optional<T>
     */
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent()) {
            return this;
        } else {
            return predicate.test(value) ? this : empty();
        }
    }

    /**
     * 如果value不为null,那么使用Function实现类的apply(T value)方法返回的value创建Optional<U>并返回
     * 如果value为null,那么返回空的的Optional<T>
     */
    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));
        }
    }

    /**
     * 如果value不为null,那么使用Function实现类的apply(T value)方法创建Optional<U>并返回
     * 如果value为null,那么返回空的的Optional<T>
     */
    public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent()) {
            return empty();
        } else {
            @SuppressWarnings("unchecked")
            Optional<U> r = (Optional<U>) mapper.apply(value);
            return Objects.requireNonNull(r);
        }
    }

    /**
     * 如果value不为null,那么使用Supplier实现类的get()方法创建Optional<T>并返回
     * 如果value为null,那么返回空的的Optional<T>
     */
    public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
        Objects.requireNonNull(supplier);
        if (isPresent()) {
            return this;
        } else {
            Optional<T> r = (Optional<T>) supplier.get();
            return Objects.requireNonNull(r);
        }
    }

    /**
     * 如果value不为null,那么返回value
	 * 如果value为null,那么返回传入的值
     */
    public T orElse(T other) {
        return value != null ? value : other;
    }

    /**
     * 如果value不为null,那么返回value
	 * 如果value为null,那么返回Supplier实现类的get()方法返回的值
     */
    public T orElseGet(Supplier<? extends T> supplier) {
        return value != null ? value : supplier.get();
    }

    /**
     * 如果value不为null,那么返回value
	 * 如果value为null,那么抛出NoSuchElementException
     */
    public T orElseThrow() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

    /**
     * 如果value不为null,那么返回value
	 * 如果value为null,那么抛出Supplier实现类的get()方法返回的异常
     */
    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

    /**
     * 判断两个Optional<T>是否相等,最终判断的是value是否相等
     */
    @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);
    }

    /**
     * 返回value的哈希值
     */
    @Override
    public int hashCode() {
        return Objects.hashCode(value);
    }

    /**
     * 返回Optional<T>的toString()
     */
    @Override
    public String toString() {
        return value != null
            ? String.format("Optional[%s]", value)
            : "Optional.empty";
    }
	
	public Stream<T> stream() {
        if (!isPresent()) {
            return Stream.empty();
        } else {
            return Stream.of(value);
        }
    }
}

分享:

低价透明

统一报价,无隐形消费

金牌服务

一对一专属顾问7*24小时金牌服务

信息保密

个人信息安全有保障

售后无忧

服务出问题客服经理全程跟进