java一个校验对象是否为null的豪华大礼包

自写的校验所有类型是否为null的工具类， 懒人福音，嘎嘎好用。

/**
 * 一个校验对象是否为null的豪华大礼包
 * 可以校验：Collection,Map,String,Enumeration,Iterator,以及所有数组类型
 *
 */
public final class ValidatorPlus {

    /**
     * 禁止实例化这个类
     */
    private ValidatorPlus() {
        //AssertionError不是必须的. 但它可以避免不小心在类的内部调用构造器. 保证该类在任何情况下都不会被实例化.
        throw new AssertionError(getClass().getName() + " 禁止实例化!");
    }

    /**
     * 判断对象是否不为Null或者Empty,调用 #isNull(Object) 方法
     *
     * @param value 可以是Collection,Map,String,Enumeration,Iterator,以及所有数组类型
     * @return 如果是null, 返回false
     * 如果是空也返回false
     * 其他情况返回true
     * 如果不是上述类型,不判断empty,返回true
     */
    public static boolean isNotNull(Object value) {
        return !isNull(value);
    }

    /**
     * 判断对象是否为Null或者Empty
     *
     * @param value 可以是Collection,Map,String,Enumeration,Iterator,以及所有数组类型
     * @return 如果是null, 返回true
     * 其他情况返回false
     * 如果不是上述类型,不判断empty,返回false
     */
    public static boolean isNull(Object value) {
        if (Objects.isNull(value)) {
            return true;
        }

        // 字符串
        if (value instanceof String) {
            return isBlank(value.toString());
        }

        // 集合
        if (value instanceof Collection) {
            return ((Collection<?>) value).isEmpty();
        }

        // map
        if (value instanceof Map) {
            return ((Map<?, ?>) value).isEmpty();
        }

        // 枚举
        if (value instanceof Enumeration) {
            return !((Enumeration<?>) value).hasMoreElements();
        }

        // Iterator迭代器
        if (value instanceof Iterator) {
            return !((Iterator<?>) value).hasNext();
        }

        // 数组
        if (arrayIsNull(value)) {
            return true;
        }
        // 这里可以扩展
        return false;
    }

    /**
     * 数组 类型的验证,区分 primitive 和包装类型.
     *
     * @param value 可以是
     *              Object[] 二维数组属于这个类型
     *              byte[]
     *              boolean[]
     *              char[]
     *              int[]
     *              long[]
     *              short[]
     *              float[]
     *              double[]
     * @return 如果是数组类型(区分 primitive和包装类型), 判断其length==0;
     * 如果不是 直接返回false
     */
    private static boolean arrayIsNull(Object value) {
        // 数组 Integer/String...自定义的对象User.等数组也 instanceof Object[]
        if (value instanceof Object[]) {
            return ((Object[]) value).length == 0;
        }

        // primitive ints
        if (value instanceof int[]) {
            return ((int[]) value).length == 0;
        }

        // primitive long
        if (value instanceof long[]) {
            return ((long[]) value).length == 0;
        }

        // primitive float
        if (value instanceof float[]) {
            return ((float[]) value).length == 0;
        }

        // primitive double
        if (value instanceof double[]) {
            return ((double[]) value).length == 0;
        }

        // primitive char
        if (value instanceof char[]) {
            return ((char[]) value).length == 0;
        }

        // primitive boolean
        if (value instanceof boolean[]) {
            return ((boolean[]) value).length == 0;
        }

        // primitive byte
        if (value instanceof byte[]) {
            return ((byte[]) value).length == 0;
        }

        // primitive short
        if (value instanceof short[]) {
            return ((short[]) value).length == 0;
        }
        return false;
    }

    /**
     * <p>检查 String 是否为空格、空 ("") 或 null。</p>
     *
     * <pre>
     * StringUtils.isBlank(null)      = true
     * StringUtils.isBlank("")        = true
     * StringUtils.isBlank(" ")       = true
     * StringUtils.isBlank("bob")     = false
     * StringUtils.isBlank("  bob  ") = false
     * </pre>
     *
     * @param str 要检查的 String 可能为 null
     * @return <code>true</code> 如果 String 为 null、空或空格
     */
    private static boolean isBlank(String str) {

        if (str == null || str.isEmpty()) {
            return true;
        }

        for (int i = 0; i < str.length(); i++) {
            if ((!Character.isWhitespace(str.charAt(i)))) {
                return false;
            }
        }
        return true;
    }
}