一、应用场景
有没有遇到过这样的代码:
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,包含第一个参数,但不包含第二个参数等。
可以自己探索一下,如果有问题欢迎弹我。