简单的条件判断(参数校验)工具类

简单替代需要经常写的if-else

package util;

import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.Map;
import java.util.Objects;

/**
 * 条件判断工具类
 *
 * @author wd
 */
public class OptionalUtil {

    /**
     * 如果参数为true抛出异常
     *
     * @param isTrue       表达式
     * @param errorMessage 异常信息
     * @author wd
     * @date 2022/1/25
     */
    public static void isTrue2Throw(boolean isTrue, String errorMessage) {
        if (isTrue) {
            throw new RuntimeException(errorMessage);
        }
    }

    /**
     * 参数为true时执行操作
     *
     * @param isTrue   表达式
     * @param runnable 执行操作
     * @author wd
     * @date 2022/1/25
     */
    public static void isTrue2Do(boolean isTrue, Runnable runnable) {
        if (isTrue) {
            runnable.run();
        }
    }

    /**
     * 参数为true或false时，分别进行不同的操作
     *
     * @param isTrue        表达式
     * @param trueRunnable  为true时操作
     * @param falseRunnable 为false时操作
     * @author wd
     * @date 2022/1/25
     */
    public static void isTureOrFalse(boolean isTrue, Runnable trueRunnable, Runnable falseRunnable) {
        if (isTrue) {
            trueRunnable.run();
        } else {
            falseRunnable.run();
        }
    }

    /**
     * 如果是null则抛异常
     *
     * @param object       判断对象
     * @param errorMessage 异常信息
     * @author wd
     * @date 2022/1/25
     */
    public static void isNull2Throw(Object object, String errorMessage) {
        isTrue2Throw(object == null, errorMessage);
    }

    /**
     * 如果不是null则执行操作
     *
     * @param object   判断对象
     * @param runnable 执行的操作
     * @author wd
     * @date 2022/1/25
     */
    public static void isNotNull2Do(Object object, Runnable runnable) {
        isTrue2Do(object != null, runnable);
    }

    /**
     * 是null或空白则抛异常
     *
     * @param str          判断字符串
     * @param errorMessage 异常信息
     * @author wd
     * @date 2022/1/25
     */
    public static void isBlank2Throw(String str, String errorMessage) {
        isTrue2Throw(isBlank(str), errorMessage);
    }

    /**
     * 不是null不是空白则执行操作
     *
     * @param str      判断字符串
     * @param runnable 执行的操作
     * @author wd
     * @date 2022/1/25
     */
    public static void isNotBlank2Do(String str, Runnable runnable) {
        isTrue2Do(isNotBlank(str), runnable);
    }

    /**
     * 对象为null或空则抛异常
     * 支持：Map/Collection/Array
     *
     * @param obj          判断对象
     * @param errorMessage 异常信息
     * @author wd
     * @date 2022/1/25
     */
    public static void isEmpty2Throw(Object obj, String errorMessage) {
        isTrue2Throw(isEmpty(obj), errorMessage);
    }

    /**
     * 判断指定对象是否为空，支持：Map/Collection/Array
     * 如果类型不支持，返回false
     *
     * @param obj 被判断的对象
     * @return 是否为空
     * @author wd
     * @date 2022/1/27
     */
    public static boolean isEmpty(Object obj) {
        if (null == obj) {
            return true;
        }
        if (obj instanceof Map) {
            Map map = (Map) obj;
            return map.isEmpty();
        } else if (obj instanceof Collection) {
            Collection collection = (Collection) obj;
            return collection.isEmpty();
        } else if (obj.getClass().isArray()) {
            return 0 == Array.getLength(obj);
        }
        return false;
    }

    /**
     * 对象不是null不为空则执行操作
     * 支持：Map/Collection/Array
     *
     * @param obj      判断对象
     * @param runnable 执行的操作
     * @author wd
     * @date 2022/1/25
     */
    public static void isNotEmpty2Do(Object obj, Runnable runnable) {
        isTrue2Do(!isEmpty(obj), runnable);
    }

    /**
     * 有null则抛出异常
     *
     * @param errorMessage 异常信息
     * @param objs         要判断的对象 可变参数
     * @author wd
     * @date 2022/1/26
     */
    public static void hasNull2Throw(String errorMessage, Object... objs) {
        isTrue2Throw(hasNull(objs), errorMessage);
    }

    /**
     * 有null或空白则抛异常
     *
     * @param errorMessage 异常信息
     * @param strs         要判断的字符串 可变参数
     * @author wd
     * @date 2022/1/26
     */
    public static void hasBlank2Throw(String errorMessage, String... strs) {
        isTrue2Throw(hasBlank(strs), errorMessage);
    }

    /**
     * 是否有null
     *
     * @param objs 可变参数
     * @return {@link boolean }
     * @author wd
     * @date 2022/1/27
     */
    public static boolean hasNull(Object... objs) {
        if (null == objs) {
            return true;
        }
        if (objs.length == 0) {
            return false;
        }
        return Arrays.stream(objs).anyMatch(Objects::isNull);
    }

    /**
     * 是否有null或空字符串
     *
     * @param strs 可变参数
     * @return {@link boolean }
     * @author wd
     * @date 2022/1/27
     */
    public static boolean hasBlank(String... strs) {
        if (null == strs) {
            return true;
        }
        if (strs.length == 0) {
            return false;
        }
        return Arrays.stream(strs).anyMatch(OptionalUtil::isBlank);
    }

    /**
     * 是否为null或空字符串
     *
     * @param str 字符串
     * @return {@link boolean }
     * @author wd
     * @date 2022/1/27
     */
    public static boolean isBlank(String str) {
        if (null != str && str.trim().length() > 0) {
            return false;
        }
        return true;
    }

    /**
     * 是否不为null或空字符串
     *
     * @param str 字符串
     * @return {@link boolean }
     * @author wd
     * @date 2022/1/27
     */
    public static boolean isNotBlank(String str) {
        return !isBlank(str);
    }

    /**
     * 比较两个对象是否相等
     * 相同的条件有两个，满足其一即可：
     * <p>
     * 1.obj1 == null && obj2 == null
     * <p>
     * 2.obj1.equals(obj2)
     * <p>
     * 3.如果是BigDecimal比较，0 == obj1.compareTo(obj2)
     *
     * @param obj1 对象1
     * @param obj2 对象2
     * @return 是否相等
     * @author wd
     * @date 2022/1/27
     */
    public static boolean equals(Object obj1, Object obj2) {
        if (obj1 instanceof BigDecimal && obj2 instanceof BigDecimal) {
            BigDecimal bigNum1 = (BigDecimal) obj1;
            BigDecimal bigNum2 = (BigDecimal) obj2;
            return 0 == bigNum1.compareTo(bigNum2);
        }
        return Objects.equals(obj1, obj2);
    }
}

注意点:

 解决方案:

1.使用final数组

2. 使用原子类

 3.将变量提为静态成员变量(大可不必)