import java.io.File;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.util.Objects;
import java.util.regex.Pattern;
/**
* 常用工具类
* @author zql
* @createTime 2020-12-05 15:58:33
* @version 1.1
* @modifyLog 1.1 优化代码
*
*/
public class Common {
/**
* 屏蔽构造函数,避免被实例化
*/
private Common() {}
/**
* 打印异常信息
* @author zql
* @createTime 2020-12-05 15:59:09
*
* @param message 异常信息,建议异常信息不要为""或者null
* @param e 异常对象
*/
public static void printException(String message, Exception e) {
// LogUtil:https://blog.csdn.net/mr_zql/article/details/111415849
LogUtil.resetLogFileName("error");
if (Objects.nonNull(message) || Objects.nonNull(e)) {
LogUtil.getLogger().error(message, e);
}
}
/**
* 比较两个字符串是否相同
* @author zql
* @createTime 2020-12-05 16:00:13
*
* @param s1 字符串1
* @param s2 字符串2
* @return 比较结果,相同返回true,不相同返回false
*/
public static boolean equalsString(String s1, String s2) {
if (Objects.isNull(s1)) {
return Objects.isNull(s2);
} else {
return s1.equals(s2);
}
}
/**
* 比较两个字符串是否相同,忽略大小写
* @author zql
* @createTime 2020-12-05 16:01:23
*
* @param s1 字符串1
* @param s2 字符串2
* @return 比较结果,相同返回true,不相同返回false
*/
public static boolean equalsStringIgnoreCase(String s1, String s2) {
if (Objects.isNull(s1)) {
return Objects.isNull(s2);
} else {
return s1.equalsIgnoreCase(s2);
}
}
/**
* 比较两个字符
* @author zql
* @createTime 2020-12-05 16:02:10
*
* @param s1 字符串1
* @param s2 字符串2
* @return 比较结果,s1 = s2返回值等于0,s1 < s2返回值小于0,s1 > s2返回值大于0
*/
public static int compareString(String s1, String s2) {
if (Objects.isNull(s1)) {
return Objects.isNull(s2) ? 0 : -1;
} else if (Objects.isNull(s2)) {
return Objects.isNull(s1) ? 0 : 1;
} else {
return s1.compareTo(s2);
}
}
/**
* 比较两个字符串是否相同,忽略大小写
* @author zql
* @createTime 2020-12-05 16:03:28
*
* @param s1 字符串1
* @param s2 字符串2
* @return 比较结果,s1 = s2返回值等于0,s1 < s2返回值小于0,s1 > s2返回值大于0
*/
public static int compareStringIgnoreCase(String s1, String s2) {
if (Objects.isNull(s1)) {
return Objects.isNull(s2) ? 0 : -1;
} else if (Objects.isNull(s2)) {
return Objects.isNull(s1) ? 0 : 1;
} else {
return s1.compareToIgnoreCase(s2);
}
}
/**
* 检查字符串中是否包含另一字符串
* @author zql
* @createTime 2020-12-05 16:04:11
*
* @param str 需要检查的字符串
* @param containsStr 包含的字符串
* @return 包含返回true,否则返回false
*/
public static boolean containsString(String str, String containsStr) {
if (Objects.isNull(str) || Objects.isNull(containsStr)) {
return false;
}
return str.contains(containsStr);
}
/**
* 检查字符串中是否包含另一字符串,检查过程中忽略大小写
* @author zql
* @createTime 2020-12-05 16:04:57
*
* @param str 需要检查的字符串
* @param containsStr 包含的字符串
* @return 包含返回true,否则返回false
*/
public static boolean containsStringIgnoreCase(String str, String containsStr) {
if (Objects.isNull(str) || Objects.isNull(containsStr)) {
return false;
}
return str.toLowerCase().contains(containsStr.toLowerCase());
}
/**
* 字符串转换整数
* @author zql
* @createTime 2020-12-05 16:06:17
*
* @param str 字符串
* @param defaultValue 转换成的缺省整数
* @return 字符串转换的整数,转换失败,则返回缺省整数
*/
public static int stringToInteger(String str, int defaultValue) {
int iValue;
try {
iValue = Integer.parseInt(str);
} catch (Exception e) {
iValue = defaultValue;
}
return iValue;
}
/**
* 字符串转换长整数
* @author zql
* @createTime 2020-12-05 16:07:30
*
* @param str 字符串
* @param defaultValue 转换成的缺省整数
* @return 字符串转换的整数,转换失败,则返回缺省长整数
*/
public static long stringToLong(String str, long defaultValue) {
long lValue;
try {
lValue = Long.parseLong(str);
} catch (Exception e) {
lValue = defaultValue;
}
return lValue;
}
/**
* 字符串转换字节
* @author zql
* @createTime 2020-12-05 16:08:10
*
* @param str 字符串
* @param defaultValue 转换成的缺省字节
* @return 字符串转换的字节,转换失败,则返回缺省字节
*/
public static byte stringToByte(String str, byte defaultValue) {
byte value;
try {
value = Byte.parseByte(str);
} catch (Exception e) {
value = defaultValue;
}
return value;
}
/**
* 指定的类型是否是包装类
* @author zql
* @createTime 2020-12-05 16:16:54
*
* @param cls 指定的类型
* @return 类型是否是包装类
*/
@SuppressWarnings("rawtypes")
public static boolean isWrapClass(Class cls) {
boolean result;
if (cls == java.sql.Blob.class) {
return true;
}
try {
Field field = cls.getField("TYPE");
Class type = (Class)field.get(null);
result = type.isPrimitive();
} catch (Exception e) {
return false;
}
return result ? result : cls.equals(String.class);
}
/**
* 指定的类型是否是包装类或者基本类型
* @author zql
* @createTime 2020-12-05 16:17:31
*
* @param cls 指定的类型
* @return 类型是否是包装类或者基本类型
*/
@SuppressWarnings("unchecked")
public static <T> boolean isWarpClassOrSimpleType(Class<T> cls) {
// object instanceof String, Number, Boolean, Character, null
boolean result;
try {
// 判断是否为基本类型:int, double, float, long, short, boolean, byte, char,void
result = cls.isPrimitive();
if (!result) {
Field field = cls.getField("TYPE");
Class<T> type = (Class<T>)field.get(null);
result = type.isPrimitive();
}
} catch (Exception e) {
result = false;
}
return result ? result : cls.equals(String.class);
}
/**
* 用于对象数组的创建的泛型方法
* @author zql
* @createTime 2020-12-05 16:17:52
*
* @param ts 可变泛型参数
* @return 返回泛型数组
*/
@SafeVarargs
public static <T> T[] arrayOf(T...ts){
return ts;
}
/**
* 比较两个对象是否相等
* @author zql
* @createTime 2020-12-05 16:18:08
*
* @param obj1 第一个对象
* @param obj2 第二个对象
* @return 两个对象相等返回true,否则返回false
*/
public static boolean equalsObject(Object obj1, Object obj2) {
if (Objects.isNull(obj1)) {
return Objects.isNull(obj2);
}
return obj1.equals(obj2);
}
/**
* 转换对象为Long对象
* @author zql
* @createTime 2020-12-05 16:18:57
*
* @param obj 转换的对象
* @return 转换后的Long对象,但obj为空或者转换异常时返回-1
*/
public static long getLong(Object obj) {
if (Objects.isNull(obj)) {
return -1;
}
try {
return (Long) obj;
} catch (Exception e) {
return -1;
}
}
/**
* 转换对象为Long对象
* @author zql
* @createTime 2020-12-05 16:19:16
*
* @param obj 转换的对象
* @param min 转换目标值的最小值
* @return 转换后的Long对象,如果转换后的Long小于最小值,则返回最小值
*/
public static long getLongMin(Object obj, long min) {
long result = Common.getLong(obj);
if (result != -1 && result <= min) {
result = min;
}
return result;
}
/**
* 将一组整形数字组合成一个以指定分隔符分割成的字符串
* @author zql
* @createTime 2020-12-05 16:19:39
*
* @param items 整形数字集合
* @param separator 分隔符
* @return 组合成的字符串
*/
public final static String combineString(Integer[] items, String separator) {
if (Common.isEmptyArray(items)) {
return "";
}
StringBuffer sb = new StringBuffer();
for (int i = 0; i < items.length; i++) {
sb.append(items[i]);
if (i != items.length - 1) {
sb.append(separator);
}
}
return sb.toString();
}
/**
* 将一组整形数字组合成一个以指定分隔符分割成的字符串
* @author zql
* @createTime 2020-12-05 16:20:55
*
* @param items 整形数字集合
* @param separator 分隔符
* @return 组合成的字符串
*/
public final static String combineString(int[] items, String separator) {
if (Common.isEmptyArray(items)) {
return "";
}
StringBuffer sb = new StringBuffer();
for (int i = 0; i < items.length; i++) {
sb.append(items[i]);
if (i != items.length - 1) {
sb.append(separator);
}
}
return sb.toString();
}
/**
* 将一组长整形数字组合成一个以指定分隔符分割成的字符串
* @author zql
* @createTime 2020-12-05 16:21:38
*
* @param items 长整形数字集合
* @param separator 分隔符
* @return 组合成的字符串
*/
public final static String combineString(Long[] items, String separator) {
if (Common.isEmptyArray(items)) {
return "";
}
StringBuffer sb = new StringBuffer();
for (int i = 0; i < items.length; i++) {
sb.append(items[i]);
if (i != items.length - 1) {
sb.append(separator);
}
}
return sb.toString();
}
/**
* 将一组长整形数字组合成一个以指定分隔符分割成的字符串
* @author zql
* @createTime 2020-12-05 16:22:21
*
* @param items 长整形数字集合
* @param separator 分隔符
* @return 组合成的字符串
*/
public final static String combineString(long[] items, String separator) {
if (Common.isEmptyArray(items)) {
return "";
}
StringBuffer sb = new StringBuffer();
for (int i = 0; i < items.length; i++) {
sb.append(items[i]);
if (i != items.length - 1) {
sb.append(separator);
}
}
return sb.toString();
}
/**
* 将一组双精度数字组合成一个以指定分隔符分割成的字符串
* @author zql
* @createTime 2020-12-05 16:23:07
*
* @param items 长整形数字集合
* @param separator 分隔符
* @return 组合成的字符串
*/
public final static String combineString(Double[] items, String separator) {
if (Common.isEmptyArray(items)) {
return "";
}
StringBuffer sb = new StringBuffer();
for (int i = 0; i < items.length; i++) {
sb.append(items[i]);
if (i != items.length - 1) {
sb.append(separator);
}
}
return sb.toString();
}
/**
* 将一组双精度数字组合成一个以指定分隔符分割成的字符串
* @author zql
* @createTime 2020-12-05 16:23:47
*
* @param items 长整形数字集合
* @param separator 分隔符
* @return 组合成的字符串
*/
public final static String combineString(double[] items, String separator) {
if (Common.isEmptyArray(items)) {
return "";
}
StringBuffer sb = new StringBuffer();
for (int i = 0; i < items.length; i++) {
sb.append(items[i]);
if (i != items.length - 1) {
sb.append(separator);
}
}
return sb.toString();
}
/**
* 将一组字符串数组合成一个以指定分隔符分割成的字符串
* @author zql
* @createTime 2020-12-05 16:24:21
*
* @param items 长整形数字集合
* @param separator 分隔符
* @return 组合成的字符串
*/
public final static String combineString(String[] items, String separator) {
if (Common.isEmptyArray(items)) {
return "";
}
StringBuffer sb = new StringBuffer();
for (int i = 0; i < items.length; i++) {
sb.append(items[i]);
if (i != items.length - 1) {
sb.append(separator);
}
}
return sb.toString();
}
/**
* 创建文件,如果文件所在路径不存在则创建路径
* @author zql
* @createTime 2020-12-05 16:24:53
*
* @param filePath 文件完整名称(包含路径)
* @return 创建的文件
*/
public static File createFile(String filePath) {
File targetFile = new File(filePath);
if (targetFile.isDirectory()) {
targetFile.mkdirs();
} else {
File parentFile = targetFile.getParentFile();
if (!parentFile.exists()) {
parentFile.mkdirs();
targetFile = new File(targetFile.getAbsolutePath());
}
}
return targetFile;
}
/**
* 创建文件,如果文件所在路径不存在则创建路径
* @author zql
* @createTime 2020-12-05 16:25:19
*
* @param filePath 文件完整名称(包含路径)
* @param isDirectory 文件是否为文件夹
* @return 创建的文件
*/
public static File createFile(String filePath, boolean isDirectory) {
File targetFile = new File(filePath);
if (isDirectory) {
targetFile.mkdirs();
} else {
File parentFile = targetFile.getParentFile();
if (!parentFile.exists()) {
parentFile.mkdirs();
targetFile = new File(targetFile.getAbsolutePath());
}
}
return targetFile;
}
/**
* 获取用户当前的工作目录
* @author zql
* @createTime 2020-12-05 16:25:43
*
* @return 用户当前的工作目录
*/
public static String getSystemRunPath() {
return System.getProperty("user.dir");
}
/**
* 对某个数保留小数位数的
* @author zql
* @createTime 2020-12-05 16:26:02
*
* @param num 某个数
* @param type 类型,1四舍五入,2五舍六入,3进位处理(就是直接加1),4直接去掉尾数
* <pre>
* type = 2,五舍六入时,需要看要求精度后面的第二位(如果存在)是否大于等于5,如果是则会进位
* </pre>
* @param count 要保留的小数位数
* @return 返回double类型的结果
* <pre>
* 如果num不是数字时,返回0
* 如果不处于类型内,则默认四舍五入
* 如果count小于1时,默认为保留两位小数
* </pre>
*
*/
public static double getDouble(String num, int type, int count) {
return Common.getBigDecimal(num, type, count).doubleValue();
}
/**
* 对某个数保留小数位数的
* @author zql
* @createTime 2020-12-05 16:26:02
*
* @param num 某个数
* @param type 类型,1四舍五入,2五舍六入,3进位处理(就是直接加1),4直接去掉尾数
* <pre>
* type = 2,五舍六入时,需要看要求精度后面的第二位(如果存在)是否大于等于5,如果是则会进位
* </pre>
* @param count 要保留的小数位数
* @return 返回double类型的结果
* <pre>
* 如果num不是数字时,返回0
* 如果不处于类型内,则默认四舍五入
* 如果count小于1时,默认为保留两位小数
* </pre>
*
*/
public static BigDecimal getBigDecimal(String num, int type, int count) {
if (!Common.isNumber(num)) {
return BigDecimal.ZERO;
}
if (type < 1 || type > 4) {
type = 1;
}
if (count < 1) {
count = 2;
}
BigDecimal b = new BigDecimal(num);
BigDecimal r;
switch (type) {
case 1:
// 四舍五入
r = b.setScale(count, BigDecimal.ROUND_HALF_UP);
break;
case 2:
// 五舍六入,需要看要求精度后面的第二位(如果存在)是否大于等于5,如果是则会进位
r = b.setScale(count, BigDecimal.ROUND_HALF_DOWN);
break;
case 3:
// 进位处理(就是直接加1)
r = b.setScale(count, BigDecimal.ROUND_UP);
break;
case 4:
// 直接去掉尾数
r = b.setScale(count, BigDecimal.ROUND_DOWN);
break;
default:
r = BigDecimal.ZERO;
}
return r;
}
/**
* 是否和正则表达式匹配
* @author zql
* @createTime 2020-12-05 16:27:39
*
* @param regex 正则表达式
* @param matchStr 要匹配的字符串
* @return 匹配成功返回true,否则返回false;
*/
public static boolean isMatch(String regex, String matchStr) {
if (Objects.isNull(matchStr) || matchStr.trim().length() == 0) {
return false;
}
Pattern pattern = Pattern.compile(regex);
return pattern.matcher(matchStr).matches();
}
/**
* 判断字符串是否是正整数
* @author zql
* @createTime 2020-12-05 16:28:48
*
* @param str
* @return 是正整数返回true,否则返回false
*/
public static boolean isPositiveInteger(String str) {
return Common.isMatch("^\\+{0,1}[1-9]\\d*", str);
}
/**
* 判断字符串是否是负整数
* @author zql
* @createTime 2020-12-05 16:29:18
*
* @param str 是负整数返回true,否则返回false
* @return
*/
public static boolean isNegativeInteger(String str) {
return Common.isMatch("^-[1-9]\\d*", str);
}
/**
* 判断字符串是否是整数
* @author zql
* @createTime 2020-12-05 16:29:45
*
* @param str 是整数返回true,否则返回false
* @return
*/
public static boolean isInteger(String str) {
return Common.isMatch("[-\\+]{0,1}0|^\\+{0,1}[1-9]\\d*|^-[1-9]\\d*", str);
}
/**
* 判断字符串是否是正小数
* @author zql
* @createTime 2020-12-05 16:30:05
*
* @param str
* @return 是正小数返回true,否则返回false
*/
public static boolean isPositiveDecimal(String str) {
// 例,因为0.0=0,它的本质是0,小数点后都是0理论上是一个错误的小数,但double类型可支持,如需要则去掉if
if (Common.isMatch("^[0]\\.[0]+", str)) {
return false;
}
return Common.isMatch("\\+{0,1}\\d{1}\\.\\d+|\\+{0,1}[1-9]{1}\\d*\\.\\d+", str);
}
/**
* 判断字符串是否是负小数
* @author zql
* @createTime 2020-12-05 16:30:43
*
* @param str 是负小数返回true,否则返回false
* @return
*/
public static boolean isNegativeDecimal(String str) {
// 例,因为0.0=0,它的本质是0,小数点后都是0理论上是一个错误的小数,但double类型可支持,如需要则去掉if
if (Common.isMatch("^[0]\\.[0]+", str)) {
return false;
}
return Common.isMatch("^-\\d{1}\\.\\d+|^-[1-9]{1}\\d*\\.\\d+", str);
}
/**
* 判断字符串是否是小数
* @author zql
* @createTime 2020-12-05 16:31:02
*
* @param str
* @return 是小数返回true,否则返回false
*/
public static boolean isDecimal(String str) {
// 例,因为0.0=0,它的本质是0,小数点后都是0理论上是一个错误的小数,但double类型可支持,如需要则去掉if
if (Common.isMatch("^[0]\\.[0]+", str)) {
return false;
}
return Common.isMatch("[-\\+]{0,1}\\d{1}\\.\\d+|[-\\+]{0,1}[1-9]{1}\\d*\\.\\d+", str);
}
/**
* 判断字符串是否是数字
* @author zql
* @createTime 2020-12-05 16:31:34
*
* @param str
* <pre>
* 小数点后都是0会判断成不是数字,例如:0.00返回的是false
* </pre>
* @return 是数字返回true,否则返回false
*/
public static boolean isNumber(String str) {
return Common.isInteger(str) || Common.isDecimal(str);
}
/**
* 判断字符串是否不是数字
* @author zql
* @createTime 2020-12-05 16:31:34
*
* @param str
* @return 不是数字返回true,是数字返回false
*/
public static boolean isNotNumber(String str) {
return !Common.isNumber(str);
}
/**
* 获取文件后缀名
* @author zql
* @createTime 2020-12-05 16:31:49
*
* @param str 文件全名或者文件路径,文件路径请包括文件全名
* @return 返回后缀名,不包括点
*/
public static String getFileSuffix(String str) {
return str.substring(str.lastIndexOf(".") + 1);
}
/**
* 判断数组是否为空
* @author zql
* @createTime 2020-12-05 16:42:46
*
* @param obj
* @return
*/
public static boolean isEmptyArray(Object[] obj) {
return Objects.isNull(obj) || obj.length <= 0;
}
/**
* 判断数组是否为空
* @author zql
* @createTime 2020-12-05 16:42:46
*
* @param i
* @return
*/
public static boolean isEmptyArray(int[] i) {
return Objects.isNull(i) || i.length <= 0;
}
/**
* 判断数组是否为空
* @author zql
* @createTime 2020-12-05 16:42:46
*
* @param d
* @return
*/
public static boolean isEmptyArray(double[] d) {
return Objects.isNull(d) || d.length <= 0;
}
/**
* 判断数组是否为空
* @author zql
* @createTime 2020-12-05 16:42:46
*
* @param l
* @return
*/
public static boolean isEmptyArray(long[] l) {
return Objects.isNull(l) || l.length <= 0;
}
}
常用工具类
最新推荐文章于 2023-05-14 19:29:49 发布