OptionalStr工具类

java.util工具包下有一个Optional工具类,对于我们做非空校验有很大的帮助。但是在实际项目使用中，很多参数都是String类型的。不单单需要判断非null，还要过滤空串，所以借鉴写了一个OptionalStr。上代码：

import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * optional对象判空，参考：https://github.com/looly/hutool/pull/1182<br>
 *
 * @param <T> Str类型
 * @author Tzx
 * @since 1.0.0
 */
public final class OptionalStr {

    private static final OptionalStr EMPTY = new OptionalStr();

    /**
     * 空值常量
     *
     * @param <T> 对象类型
     * @return 空
     */
    public static OptionalStr empty() {
        @SuppressWarnings("unchecked")
        OptionalStr none = (OptionalStr) EMPTY;
        return none;
    }

    private final String value;

    /**
     * 构造
     */
    private OptionalStr() {
        this.value = null;
    }

    /**
     * 空值会抛出空指针
     *
     * @param value Bean值
     */
    private OptionalStr(String value) {
        this.value = Objects.requireNonNull(value);
    }

    /**
     * 包装一个不能为空的 bean
     *
     * @param <T>   bean类型
     * @param value Bean值
     * @return OptionalStr
     */
    public static OptionalStr of(String value) {
        return new OptionalStr(value);
    }

    /**
     * 包装一个可能为空的 bean
     *
     * @param value  Bean值
     * @param bean类型
     * @return OptionalStr
     */
    public static OptionalStr ofBlankable(String value) {
        return isBlank(value) ? empty() : of(value);
    }

    /**
     * 取出具体的值
     *
     * @return bean值
     */
    public String get() {
        return value;
    }

    /**
     * 取出一个可能为空的对象
     *
     * @param <R> 对象类型
     * @param fn  从已有bean中获取新bean字段的函数
     * @return 新的bean
     */
    public OptionalStr getBean(Function<? super String, ? extends String> fn) {
        return isBlank() ? OptionalStr.empty() : OptionalStr.of(fn.apply(value));
    }

    /**
     * 如果目标值为空 获取一个默认值
     *
     * @param other 默认值
     * @return 空返回默认值，否则返回原值
     */

    public String orElse(String other) {
        return isNotBlank() ? this.value : other;
    }

    /**
     * 如果目标值为空 通过lambda表达式获取一个值
     *
     * @param other 默认值函数
     * @return 空返回默认值函数获得的值，否则返回原值
     */
    public String orElseGet(Supplier<? extends String> other) {
        return isBlank() ? value : other.get();
    }

    /**
     * 如果目标值为空 抛出一个异常
     *
     * @param exceptionSupplier 抛出的异常
     * @param <X>               异常类型
     * @return 非空值
     * @throws X 对象为空时抛出的异常
     */
    public <X extends Throwable> String orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (isBlank()) {
            throw exceptionSupplier.get();
        }
        return this.value;
    }

    /**
     * 检查值是否为空
     *
     * @return 是否为空
     */
    public boolean isPresent() {
        return isNotBlank();
    }

    /**
     * 如果值非空，则使用指定函数处理值
     *
     * @param consumer 处理非空对象的函数
     */
    public void ifPresent(Consumer<? super String> consumer) {
        if (isNotBlank()) {
            consumer.accept(value);
        }
    }

    private boolean isNotBlank() {
        return !isBlank();
    }

    private boolean isBlank() {
        return isBlank(value);
    }

    private static boolean isNotBlank(String str) {
        return !isBlank(str);
    }

    private static boolean isBlank(String str) {
        int length;
        if ((str == null) || ((length = str.length()) == 0)) {
            return true;
        }
        for (int i = 0; i < length; i++) {
            // 只要有一个非空字符即为非空字符串
            if (false == isBlankChar(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /**
     * 是否空白符 空白符包括空格、制表符、全角空格和不间断空格
     * @param c
     * @return
     */
    private static boolean isBlankChar(int c) {
        return Character.isWhitespace(c)
                || Character.isSpaceChar(c)
                || c == '\ufeff'
                || c == '\u202a';
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(value);
    }

}