多值判断、包含的简写EqualUtil工具类

一、应用场景

有没有遇到过这样的代码：

if(a.equal(b) && a.equal(c) && ···){

}
或者
if(a.equal(b) || a.equal(c) || ···){

}
又或者
if(a.contains(b) && a.contains(c) && ···){
}

每次遇到一个值需要和多个值进行判断的时候，if里面就要写好多equal和&&，是否包含多个值时就要写多个contains。
代码重复，如果变量名很长经常换行也会导致可读性变差，所以写个工具类方便使用。

二、工具类代码

直接复制粘贴即可使用。

public class EqualUtil {

    /**
     * TODO 用于判断args的值是否和obj值相等，全部等即返回true。
     *
     * @param obj  被比较的值
     * @param args 比较的值
     * @return
     */
    public static boolean equalsAnd(Object obj, Object... args) {
        return equalsAnd(false, obj, args);
    }

    /**
     * TODO 用于判断args的值是否和obj值相等，有一个相等即返回true。
     *
     * @param obj  被比较的值
     * @param args 比较的值
     * @return
     */
    public static boolean equalOr(Object obj, Object... args) {
        return equalOr(false, obj, args);
    }

    /**
     * TODO 用于判断忽略大小写后，args的值是否和obj值相等，全部相等即返回true。
     *
     * @param obj  被比较的值
     * @param args 比较的值
     * @return
     */
    public static boolean equalsAndIgnore(String obj, String... args) {
        return equalsAnd(true, obj, args);
    }

    /**
     * TODO 用于判断忽略大小写后，args中的某个值是否和obj值相等，有一个相等即返回true。
     *
     * @param obj  被比较的值
     * @param args 比较的值
     * @return
     */
    public static boolean equalOrIgnore(String obj, String... args) {
        return equalOr(true, obj, args);
    }

    /**
     * TODO 用于判断是否包含args内所有参数。
     *
     * @param obj  被比较的值
     * @param args 比较的值
     * @return
     */
    public static boolean containAnd(String obj, String... args) {
        return containAnd(false, obj, args);
    }

    /**
     * TODO 用于判断是否包含args内某个参数。
     *
     * @param obj  被比较的值
     * @param args 比较的值
     * @return
     */
    public static boolean containOr(String obj, String... args) {
        return containOr(false, obj, args);
    }

    /**
     * TODO 用于判断是否包含args1内全部参数，但不包含args2内任何参数
     *
     * @param obj   被比较的值
     * @param args1 包含的参数
     * @param args2 不包含的参数
     * @return
     */
    public static boolean containOneNotTwo(String obj, String[] args1, String[] args2) {
        return containAnd(obj, args1) && !containOr(obj, args2);
    }

    /**
     * TODO 用于判断是否包含args1参数，但不包含args2参数
     *
     * @param obj   被比较的值
     * @param args1 包含的参数
     * @param args2 不包含的参数
     * @return
     */
    public static boolean containOneNotTwo(String obj, String args1, String args2) {
        return containOneNotTwo(obj, new String[]{args1}, new String[]{args2});
    }

    /**
     * TODO 忽略大小写，用于判断是否包含args1内全部参数，但不包含args2内任何参数
     *
     * @param obj   被比较的值
     * @param args1 包含的参数
     * @param args2 不包含的参数
     * @return
     */
    public static boolean containOneNotTwoIgnore(String obj, String[] args1, String[] args2) {
        return containAnd(true, obj, args1) && !containOr(true, obj, args2);
    }

    /**
     * TODO 忽略大小写，用于判断是否包含args1参数，但不包含args2参数
     *
     * @param obj   被比较的值
     * @param args1 包含的参数
     * @param args2 不包含的参数
     * @return
     */
    public static boolean containOneNotTwoIgnore(String obj, String args1, String args2) {
        return containOneNotTwoIgnore(obj, new String[]{args1}, new String[]{args2});
    }

    private static boolean equalsAnd(boolean ignore, Object obj, Object... args) {
        if (ignore && obj instanceof String) {
            for (Object arg : args) {
                if (!((String) arg).equalsIgnoreCase((String) obj))
                    return false;
            }
        } else {
            for (Object arg : args) {
                if (arg.hashCode() != obj.hashCode() || !arg.equals(obj))
                    return false;
            }
        }
        return true;
    }

    private static boolean equalOr(boolean ignore, Object obj, Object... args) {
        if (ignore && obj instanceof String) {
            for (Object arg : args) {
                if (((String) arg).equalsIgnoreCase((String) obj))
                    return true;
            }
        } else {
            for (Object arg : args) {
                if (arg.hashCode() == obj.hashCode() && arg.equals(obj))
                    return true;
            }
        }
        return false;
    }

    private static boolean containAnd(boolean ignore, String obj, String... args) {
        obj = ignore ? obj.toUpperCase() : obj;
        for (String arg : args) {
            arg = ignore ? arg.toUpperCase() : arg;
            if (!arg.contains(obj))
                return false;
        }
        return true;
    }

    private static boolean containOr(boolean ignore, String obj, String... args) {
        obj = ignore ? obj.toUpperCase() : obj;
        for (String arg : args) {
            arg = ignore ? arg.toUpperCase() : arg;
            if (arg.contains(obj))
                return true;
        }
        return false;
    }

}

三、使用说明

！！！所有方法的被比较值都是第一个参数！！！

String str1 = "a";
String str2 = "b";
String str3 = "a";
String str4 = "A";
EqualUtil.equalsAnd(str1,str2,str3);//结果是false，因为str2是b，此方法要求所有值和str1相等。
EqualUtil.equalsOr(str1,str2,str3);//结果是true,因为str3是a，此方法只要有一个相等即可。
EqualUtil.equalsAndIgnore(str1,str3,str4);//结果是true，此方法忽略大小写后所有值相同。
EqualUtil.equalsOrIgnore(str1,str2,str4);//结果是true，此方法忽略大小写且有一个值相同。
String str5 = "abc";
String str6 = "b";
String str7 = "c";
String str8 = "d";
EqualUtil.containAnd(str5,str6,str7,str8);//结果是false，此方法要求包含后面所有值。
EqualUtil.containOr(str5,str6,str7,str8);//结果是true，此方法要求包含其中一个值即可。
......
还有一些包含方法，例如containOneNotTwo，包含第一个参数，但不包含第二个参数等。
可以自己探索一下，如果有问题欢迎弹我。