ruoyi
/
RuoYi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Pre Merge pull request !215 from weiwsy/master

This commit is contained in:
weiwsy 2020-09-30 15:44:56 +08:00 committed by Gitee
parent d2059ee282 d9f139411d
commit b8dd27c6dd
1 changed files with 414 additions and 408 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

822
ruoyi-common/src/main/java/com/ruoyi/common/utils/StringUtils.java
View File

@ -1,408 +1,414 @@
package com.ruoyi.common.utils; package com.ruoyi.common.utils;
import java.util.Collection; import java.util.Collection;
import java.util.Map; import java.util.Map;
import com.ruoyi.common.core.text.StrFormatter; import com.ruoyi.common.core.text.StrFormatter;
/** /**
* 字符串工具类 * 字符串工具类
* *
* @author ruoyi * @author ruoyi
*/ */
public class StringUtils extends org.apache.commons.lang3.StringUtils public class StringUtils extends org.apache.commons.lang3.StringUtils
{ {
/** 空字符串 */ /** 空字符串 */
private static final String NULLSTR = ""; private static final String NULLSTR = "";
/** 下划线 */ /** 下划线 */
private static final char SEPARATOR = '_'; private static final char SEPARATOR = '_';
/** /**
* 获取参数不为空值 * 获取参数不为空值
* *
* @param value defaultValue 要判断的value * @param value defaultValue 要判断的value
* @return value 返回值 * @return value 返回值
*/ */
public static <T> T nvl(T value, T defaultValue) public static <T> T nvl(T value, T defaultValue)
{ {
return value != null ? value : defaultValue; return value != null ? value : defaultValue;
} }
/** /**
* * 判断一个Collection是否为空， 包含List，Set，Queue * * 判断一个Collection是否为空， 包含List，Set，Queue
* *
* @param coll 要判断的Collection * @param coll 要判断的Collection
* @return true：为空 false：非空 * @return true：为空 false：非空
*/ */
public static boolean isEmpty(Collection<?> coll) public static boolean isEmpty(Collection<?> coll)
{ {
return isNull(coll) || coll.isEmpty(); return isNull(coll) || coll.isEmpty();
} }
/** /**
* * 判断一个Collection是否非空，包含List，Set，Queue * * 判断一个Collection是否非空，包含List，Set，Queue
* *
* @param coll 要判断的Collection * @param coll 要判断的Collection
* @return true：非空 false：空 * @return true：非空 false：空
*/ */
public static boolean isNotEmpty(Collection<?> coll) public static boolean isNotEmpty(Collection<?> coll)
{ {
return !isEmpty(coll); return !isEmpty(coll);
} }
/** /**
* * 判断一个对象数组是否为空 * * 判断一个对象数组是否为空
* *
* @param objects 要判断的对象数组 * @param objects 要判断的对象数组
** @return true：为空 false：非空 ** @return true：为空 false：非空
*/ */
public static boolean isEmpty(Object[] objects) public static boolean isEmpty(Object[] objects)
{ {
return isNull(objects) || (objects.length == 0); return isNull(objects) || (objects.length == 0);
} }
/** /**
* * 判断一个对象数组是否非空 * * 判断一个对象数组是否非空
* *
* @param objects 要判断的对象数组 * @param objects 要判断的对象数组
* @return true：非空 false：空 * @return true：非空 false：空
*/ */
public static boolean isNotEmpty(Object[] objects) public static boolean isNotEmpty(Object[] objects)
{ {
return !isEmpty(objects); return !isEmpty(objects);
} }
/** /**
* * 判断一个Map是否为空 * * 判断一个Map是否为空
* *
* @param map 要判断的Map * @param map 要判断的Map
* @return true：为空 false：非空 * @return true：为空 false：非空
*/ */
public static boolean isEmpty(Map<?, ?> map) public static boolean isEmpty(Map<?, ?> map)
{ {
return isNull(map) || map.isEmpty(); return isNull(map) || map.isEmpty();
} }
/** /**
* * 判断一个Map是否为空 * * 判断一个Map是否为空
* *
* @param map 要判断的Map * @param map 要判断的Map
* @return true：非空 false：空 * @return true：非空 false：空
*/ */
public static boolean isNotEmpty(Map<?, ?> map) public static boolean isNotEmpty(Map<?, ?> map)
{ {
return !isEmpty(map); return !isEmpty(map);
} }
/** /**
* * 判断一个字符串是否为空串 * * 判断一个字符串是否为空串
* *
* @param str String * @param str String
* @return true：为空 false：非空 * @return true：为空 false：非空
*/ */
public static boolean isEmpty(String str) public static boolean isEmpty(String str)
{ {
return isNull(str) || NULLSTR.equals(str.trim()); return isNull(str) || NULLSTR.equals(str.trim());
} }
/** /**
* * 判断一个字符串是否为非空串 * * 判断一个字符串是否为非空串
* *
* @param str String * @param str String
* @return true：非空串 false：空串 * @return true：非空串 false：空串
*/ */
public static boolean isNotEmpty(String str) public static boolean isNotEmpty(String str)
{ {
return !isEmpty(str); return !isEmpty(str);
} }
/** /**
* * 判断一个对象是否为空 * * 判断一个对象是否为空
* *
* @param object Object * @param object Object
* @return true：为空 false：非空 * @return true：为空 false：非空
*/ */
public static boolean isNull(Object object) public static boolean isNull(Object object)
{ {
return object == null; return object == null;
} }
/** /**
* * 判断一个对象是否非空 * * 判断一个对象是否非空
* *
* @param object Object * @param object Object
* @return true：非空 false：空 * @return true：非空 false：空
*/ */
public static boolean isNotNull(Object object) public static boolean isNotNull(Object object)
{ {
return !isNull(object); return !isNull(object);
} }
/** /**
* * 判断一个对象是否是数组类型（Java基本型别的数组） * * 判断一个对象是否是数组类型（Java基本型别的数组）
* *
* @param object 对象 * @param object 对象
* @return true：是数组 false：不是数组 * @return true：是数组 false：不是数组
*/ */
public static boolean isArray(Object object) public static boolean isArray(Object object)
{ {
return isNotNull(object) && object.getClass().isArray(); return isNotNull(object) && object.getClass().isArray();
} }
/** /**
* 去空格 * 去空格
*/ */
public static String trim(String str) public static String trim(String str)
{ {
return (str == null ? "" : str.trim()); return (str == null ? "" : str.trim());
} }
/** /**
* 截取字符串 * 截取字符串
* *
* @param str 字符串 * @param str 字符串
* @param start 开始 * @param start 开始
* @return 结果 * @return 结果
*/ */
public static String substring(final String str, int start) public static String substring(final String str, int start)
{ {
if (str == null) if (str == null)
{ {
return NULLSTR; return NULLSTR;
} }
if (start < 0) if (start < 0)
{ {
start = str.length() + start; start = str.length() + start;
} }
if (start < 0) if (start < 0)
{ {
start = 0; start = 0;
} }
if (start > str.length()) if (start > str.length())
{ {
return NULLSTR; return NULLSTR;
} }
return str.substring(start); return str.substring(start);
} }
/** /**
* 截取字符串 * 截取字符串
* *
* @param str 字符串 * @param str 字符串
* @param start 开始 * @param start 开始
* @param end 结束 * @param end 结束
* @return 结果 * @return 结果
*/ */
public static String substring(final String str, int start, int end) public static String substring(final String str, int start, int end)
{ {
if (str == null) if (str == null)
{ {
return NULLSTR; return NULLSTR;
} }
if (end < 0) if (end < 0)
{ {
end = str.length() + end; end = str.length() + end;
} }
if (start < 0) if (start < 0)
{ {
start = str.length() + start; start = str.length() + start;
} }
if (end > str.length()) if (end > str.length())
{ {
end = str.length(); end = str.length();
} }
if (start > end) if (start > end)
{ {
return NULLSTR; return NULLSTR;
} }
if (start < 0) if (start < 0)
{ {
start = 0; start = 0;
} }
if (end < 0) if (end < 0)
{ {
end = 0; end = 0;
} }
return str.substring(start, end); return str.substring(start, end);
} }
/** /**
* 格式化文本, {} 表示占位符<br> * 格式化文本, {} 表示占位符<br>
* 此方法只是简单将占位符 {} 按照顺序替换为参数<br> * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
* 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br> * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
* 例：<br> * 例：<br>
* 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br> * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
* 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br> * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
* 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br> * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
* *
* @param template 文本模板，被替换的部分用 {} 表示 * @param template 文本模板，被替换的部分用 {} 表示
* @param params 参数值 * @param params 参数值
* @return 格式化后的文本 * @return 格式化后的文本
*/ */
public static String format(String template, Object... params) public static String format(String template, Object... params)
{ {
if (isEmpty(params) || isEmpty(template)) if (isEmpty(params) || isEmpty(template))
{ {
return template; return template;
} }
return StrFormatter.format(template, params); return StrFormatter.format(template, params);
} }
/** /**
* 下划线转驼峰命名 * 下划线转驼峰命名
*/ */
public static String toUnderScoreCase(String str) public static String toUnderScoreCase(String str)
{ {
if (str == null) if (str == null)
{ {
return null; return null;
} }
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
// 前置字符是否大写 // 前置字符是否大写
boolean preCharIsUpperCase = true; boolean preCharIsUpperCase = true;
// 当前字符是否大写 // 当前字符是否大写
boolean curreCharIsUpperCase = true; boolean curreCharIsUpperCase = true;
// 下一字符是否大写 // 下一字符是否大写
boolean nexteCharIsUpperCase = true; boolean nexteCharIsUpperCase = true;
for (int i = 0; i < str.length(); i++) for (int i = 0; i < str.length(); i++)
{ {
char c = str.charAt(i); char c = str.charAt(i);
if (i > 0) if (i > 0)
{ {
preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1)); preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
} }
else else
{ {
preCharIsUpperCase = false; preCharIsUpperCase = false;
} }
curreCharIsUpperCase = Character.isUpperCase(c); curreCharIsUpperCase = Character.isUpperCase(c);
if (i < (str.length() - 1)) if (i < (str.length() - 1))
{ {
nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1)); nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
} }
if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase) if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase)
{ {
sb.append(SEPARATOR); sb.append(SEPARATOR);
} }
else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase) else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase)
{ {
sb.append(SEPARATOR); sb.append(SEPARATOR);
} }
sb.append(Character.toLowerCase(c)); sb.append(Character.toLowerCase(c));
} }
return sb.toString(); return sb.toString();
} }
/** /**
* 是否包含字符串 * 是否包含字符串
* *
* @param str 验证字符串 * @param str 验证字符串
* @param strs 字符串组 * @param strs 字符串组
* @return 包含返回true * @return 包含返回true
*/ */
public static boolean inStringIgnoreCase(String str, String... strs) public static boolean inStringIgnoreCase(String str, String... strs)
{ {
if (str != null && strs != null) if (str != null && strs != null)
{ {
for (String s : strs) for (String s : strs)
{ {
if (str.equalsIgnoreCase(trim(s))) if (str.equalsIgnoreCase(trim(s)))
{ {
return true; return true;
} }
} }
} }
return false; return false;
} }
/** /**
* 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
* *
* @param name 转换前的下划线大写方式命名的字符串 * @param name 转换前的下划线大写方式命名的字符串
* @return 转换后的驼峰式命名的字符串 * @return 转换后的驼峰式命名的字符串
*/ */
public static String convertToCamelCase(String name) public static String convertToCamelCase(String name)
{ {
StringBuilder result = new StringBuilder(); StringBuilder result = new StringBuilder();
// 快速检查 // 快速检查
if (name == null || name.isEmpty()) if (name == null || name.isEmpty())
{ {
// 没必要转换 // 没必要转换
return ""; return "";
} }
else if (!name.contains("_")) else if (!name.contains("_"))
{ {
// 不含下划线，仅将首字母大写 // 不含下划线，仅将首字母大写
return name.substring(0, 1).toUpperCase() + name.substring(1); return name.substring(0, 1).toUpperCase() + name.substring(1);
} }
// 用下划线将原始字符串分割 // 用下划线将原始字符串分割
String[] camels = name.split("_"); String[] camels = name.split("_");
for (String camel : camels) for (String camel : camels)
{ {
// 跳过原始字符串中开头、结尾的下换线或双重下划线 // 跳过原始字符串中开头、结尾的下换线或双重下划线
if (camel.isEmpty()) if (camel.isEmpty())
{ {
continue; continue;
} }
// 首字母大写 // 首字母大写
result.append(camel.substring(0, 1).toUpperCase()); result.append(camel.substring(0, 1).toUpperCase());
result.append(camel.substring(1).toLowerCase()); result.append(camel.substring(1).toLowerCase());
} }
return result.toString(); return result.toString();
} }
/** /**
* 驼峰式命名法 * 驼峰式命名法
* 例如：user_name->userName * 例如：user_name->userName
*/ */
public static String toCamelCase(String s) public static String toCamelCase(String s)
{ {
if (s == null) if (s == null)
{ {
return null; return null;
} }
if (s.indexOf(SEPARATOR) == -1) if (s.indexOf(SEPARATOR) == -1)
{ {
return s; if (s.length()>0 && Character.isUpperCase(s.charAt(0))) {
} StringBuilder sb = new StringBuilder(s.length());
s = s.toLowerCase(); sb.append(Character.toLowerCase(s.charAt(0)));
StringBuilder sb = new StringBuilder(s.length()); sb.append(s.substring(1));
boolean upperCase = false; return sb.toString();
for (int i = 0; i < s.length(); i++) }
{ return s;
char c = s.charAt(i); }
s = s.toLowerCase();
if (c == SEPARATOR) StringBuilder sb = new StringBuilder(s.length());
{ boolean upperCase = false;
upperCase = true; for (int i = 0; i < s.length(); i++)
} {
else if (upperCase) char c = s.charAt(i);
{
sb.append(Character.toUpperCase(c)); if (c == SEPARATOR)
upperCase = false; {
} upperCase = true;
else }
{ else if (upperCase)
sb.append(c); {
} sb.append(Character.toUpperCase(c));
} upperCase = false;
return sb.toString(); }
} else
{
@SuppressWarnings("unchecked") sb.append(c);
public static <T> T cast(Object obj) }
{ }
return (T) obj; return sb.toString();
} }
}
@SuppressWarnings("unchecked")
public static <T> T cast(Object obj)
{
return (T) obj;
}
}