package com.matrix.core.tools;
|
|
import com.matrix.core.exception.GlobleException;
|
import net.sourceforge.pinyin4j.PinyinHelper;
|
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
|
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
|
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
|
import net.sourceforge.pinyin4j.format.HanyuPinyinVCharType;
|
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
|
import org.apache.commons.collections.CollectionUtils;
|
import org.springframework.util.AntPathMatcher;
|
|
import java.io.UnsupportedEncodingException;
|
import java.util.*;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
|
/**
|
* 字符串操作类，转换数据类型，切割字符串,对象比较等操作
|
*
|
* @author JIANGYOUYAO
|
* @email 935090232@qq.com
|
* @date 2017年11月29日
|
*/
|
public class StringUtils {
|
|
private static final String REPLACE_CHAR = "*";
|
|
private static final int SAVA_CHAR_LENGTH = 4;
|
|
private static final String EMPTY = "";
|
|
|
/**
|
* 查找指定字符串是否匹配指定字符串列表中的任意一个字符串
|
*
|
* @param str 指定字符串
|
* @param strs 需要检查的字符串数组
|
* @return 是否匹配
|
*/
|
public static boolean matches(String str, List<String> strs)
|
{
|
if (isBlank(str) || CollectionUtils.isEmpty(strs))
|
{
|
return false;
|
}
|
for (String pattern : strs)
|
{
|
if (isMatch(pattern, str))
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
/**
|
* 判断url是否与规则配置:
|
* ? 表示单个字符;
|
* * 表示一层路径内的任意字符串，不可跨层级;
|
* ** 表示任意层路径;
|
*
|
* @param pattern 匹配规则
|
* @param url 需要匹配的url
|
* @return
|
*/
|
public static boolean isMatch(String pattern, String url)
|
{
|
AntPathMatcher matcher = new AntPathMatcher();
|
return matcher.match(pattern, url);
|
}
|
|
|
/**
|
* 将字符串中的某些值用指定字符代替
|
*
|
* @param str 原始字符串
|
* @param saveLength 保留位数
|
* @param replaceChar 替换成的字符
|
* @return
|
*/
|
public static String replaceStr(String str, int saveLength, String replaceChar) {
|
|
if (saveLength <= 0) {
|
saveLength = SAVA_CHAR_LENGTH;
|
}
|
|
if (replaceChar == null) {
|
replaceChar = REPLACE_CHAR;
|
}
|
|
if (isBlank(str) || str.length() < saveLength) {
|
return "";
|
}
|
|
char[] chars = str.toCharArray();
|
StringBuffer stb = new StringBuffer();
|
for (int i = 0; i < chars.length; i++) {
|
if (i < (saveLength - 1) / 2 || (chars.length - i - 1) < (saveLength + 2) / 2) {
|
stb.append(chars[i]);
|
} else {
|
stb.append(replaceChar);
|
}
|
}
|
|
return stb.toString();
|
}
|
|
/**
|
* 是否为空，去除首尾空格后比较
|
*
|
* @param str
|
* @return
|
*/
|
public static boolean isBlank(String str) {
|
|
if (str == null) {
|
return true;
|
}
|
|
if (EMPTY.equals(str.trim())) {
|
return true;
|
}
|
|
return false;
|
}
|
|
/**
|
* 不为空，去除首尾空格
|
*
|
* @param str
|
* @return
|
*/
|
public static boolean isNotBlank(String str) {
|
|
if (str == null) {
|
return false;
|
}
|
|
if (EMPTY.equals(str.trim())) {
|
return false;
|
}
|
|
return true;
|
}
|
|
/**
|
* 去除字符串首尾空格
|
*
|
* @param str
|
* @return
|
*/
|
public static String trim(String str) {
|
|
if (isNotBlank(str)) {
|
return str.trim();
|
}
|
|
return str;
|
}
|
|
/**
|
* 两个字符串是否相等
|
*
|
* @param a
|
* @param b
|
* @return
|
*/
|
public static boolean equals(String a, String b) {
|
|
if (a == null && b == null) {
|
return true;
|
} else if (a != null && b != null) {
|
if (a.trim().equals(b.trim())) {
|
return true;
|
}
|
}
|
|
return false;
|
}
|
|
/**
|
* 两个字符串是否相等
|
*
|
* @param a
|
* @param b
|
* @return
|
*/
|
public static boolean notEquals(String a, String b) {
|
|
return !equals(a, b);
|
}
|
|
/**
|
* 忽略大小写后两个字符串是否相等
|
*
|
* @param a
|
* @param b
|
* @return
|
*/
|
public static boolean equalsIgnoreCase(String a, String b) {
|
if (a == null && b == null) {
|
return true;
|
} else if (a != null && b != null) {
|
return a.toUpperCase().equals(b.toUpperCase());
|
} else {
|
return false;
|
}
|
}
|
|
/**
|
* 忽略大小写后两个字符串是否相等
|
*
|
* @param a
|
* @param b
|
* @return
|
*/
|
public static boolean notEqualsIgnoreCase(String a, String b) {
|
|
return !equalsIgnoreCase(a, b);
|
}
|
|
/**
|
* 用字符串split风格字符串str成数组
|
*
|
* @param str
|
* @param split
|
* @return
|
*/
|
public static String[] stringToArray(String str, String split) {
|
|
if (isBlank(str)) {
|
return null;
|
} else {
|
return str.split(split);
|
}
|
}
|
|
/**
|
* 如果值为null或者是空格则显示空
|
*
|
* @param str
|
* @return
|
*/
|
public static String getString(String str) {
|
|
if (isBlank(str)) {
|
return EMPTY;
|
}
|
|
return str.trim();
|
}
|
|
/**
|
* 字符串如果为空或空格则返回null
|
*
|
* @param str
|
* @return
|
*/
|
public static String getNull(String str) {
|
|
if (isNotBlank(str)) {
|
return str;
|
}
|
|
return null;
|
}
|
|
/**
|
* 填充字符串到指定长度
|
*
|
* @param source 原始字符串
|
* @param length 填充到长度
|
* @param chars 填充字符
|
* @param fillLeft true-左填充，false-右填充
|
* @return
|
*/
|
public static String fillStringWithChar(String source, int length, char chars, boolean fillLeft) {
|
|
if (StringUtils.isNotBlank(source) && length > 0) {
|
int realLength = length - source.length();
|
|
StringBuffer stb = new StringBuffer();
|
for (; realLength > 0; realLength--) {
|
stb.append(chars);
|
}
|
|
if (fillLeft) {
|
return stb.toString() + source;
|
} else {
|
return source + stb.toString();
|
}
|
}
|
return source;
|
}
|
|
/**
|
* 去掉json字符串两头的中括号
|
*
|
* @param jsonArrStr
|
* @return
|
*/
|
public static String getJsonObjStr(String jsonArrStr) {
|
String tempString = jsonArrStr.trim();
|
if (tempString.startsWith("[") && tempString.endsWith("]")) {
|
return tempString.substring(1, tempString.length() - 1);
|
} else {
|
return tempString;
|
}
|
}
|
|
private static final int MAX_GENERATE_COUNT = 99999;
|
|
private static int generateCount = 0;
|
|
public static synchronized String getUniqueString() {
|
|
if (generateCount > MAX_GENERATE_COUNT) {
|
generateCount = 0;
|
}
|
String uniqueNumber = Long.toString(System.currentTimeMillis()) + Integer.toString(generateCount);
|
|
generateCount++;
|
|
return uniqueNumber;
|
}
|
|
/***
|
* 针对javascript encodeURIComponent编码后进行解码
|
*
|
* @param str
|
* @return
|
* @throws UnsupportedEncodingException
|
*/
|
public static String decode(String str) throws UnsupportedEncodingException {
|
return java.net.URLDecoder.decode(str, "UTF-8");
|
}
|
|
public static String encodingUTF(String str) throws UnsupportedEncodingException {
|
if (str == null) {
|
return null;
|
}
|
return new String(str.getBytes("ISO8859-1"), "UTF-8");
|
}
|
|
/**
|
* 获得不重复的32位的随机的大写字符串
|
*
|
* @Return:String
|
* @Author: JiangYouYao
|
* @Version: V1.00 （版本号1.0)
|
* @Create Date: 2014-8-30（创建日期）
|
*/
|
public static String uuid() {
|
return UUID.randomUUID().toString().replace("-", "").toUpperCase();
|
}
|
|
/**
|
* 把一个集合转化成一个字符串，null或size为0时转化为空串
|
*/
|
public static String collToStr(Collection<?> collection, String splitPatten) {
|
if (CollectionUtils.isEmpty(collection)) {
|
return "";
|
}
|
Iterator<?> it = collection.iterator();
|
StringBuilder sb = new StringBuilder();
|
while (it.hasNext()) {
|
sb.append(it.next().toString() + splitPatten);
|
}
|
int lastIndex = sb.lastIndexOf(splitPatten);
|
return sb.substring(0, lastIndex);
|
}
|
|
/**
|
* 字符串转集合
|
*
|
* @param sour 原字符串
|
* @param splitPatten 截取规则
|
* @return List<String>
|
*/
|
public static List<String> strToColl(String sour, String splitPatten) {
|
List<String> list = new ArrayList<>();
|
if (sour != null) {
|
String[] temps = sour.split(splitPatten);
|
for (String string : temps) {
|
list.add(string);
|
}
|
}
|
return list;
|
}
|
|
/**
|
* 字符串转集合
|
*
|
* @param sour 原字符串
|
* @param splitPatten 截取规则
|
* @return List<String>
|
*/
|
public static List<String> strToCollToString(String sour, String splitPatten) {
|
List<String> list = new ArrayList<>();
|
if (sour != null) {
|
String[] temps = sour.split(splitPatten);
|
for (String string : temps) {
|
list.add(string);
|
}
|
}
|
return list;
|
}
|
|
/**
|
* 字符串转集合
|
*
|
* @param sour 原字符串
|
* @param splitPatten 截取规则
|
* @return List<String>
|
*/
|
public static List<Integer> strToCollToInteger(String sour, String splitPatten) {
|
List<Integer> list = new ArrayList<>();
|
if (sour != null) {
|
String[] temps = sour.split(splitPatten);
|
for (String string : temps) {
|
list.add(Integer.valueOf(string));
|
}
|
}
|
return list;
|
}
|
|
/**
|
* @Title: getRandomString
|
* 获取一个获得一定长度的随机数,包含大写字母及数字 @author:jyy @param length @return @return
|
* String 返回类型 @date 2016年7月19日 下午3:01:20 @throws
|
*/
|
public static String getRandomString(int length) {
|
String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
|
Random random = new Random();
|
StringBuilder sb = new StringBuilder();
|
for (int i = 0; i < length; i++) {
|
int number = random.nextInt(str.length());
|
sb.append(str.charAt(number));
|
}
|
return sb.toString();
|
}
|
|
|
|
/**
|
* 用逗号分开的存的id是否包含对应的id 如比较 123,123,124 中是否包含12这个主键 比对的方法是 字符串中是否包含"^12$"
|
* "^12,.*" 或者 ".+,12$" 或者 ".+,12,$" 或者 ".+,12,.+" 字符串
|
*/
|
public static boolean isContentSet(String id, String setStr) {
|
id = id.trim();
|
setStr = setStr.trim();
|
String reg = "^" + id + "$|^" + id + ",.*|.+," + id + "$|.+," + id + ",$|.+," + id + ",.+";
|
|
Pattern pattern = Pattern.compile(reg);
|
Matcher matcher = pattern.matcher(setStr);
|
boolean result = matcher.matches();
|
LogUtil.info("id=[" + id + "] : setStr =[" + setStr + "] :result=" + result);
|
return result;
|
}
|
|
public static List<Long> strToCollToLong(String sour, String splitPatten) {
|
List<Long> list = new ArrayList<>();
|
if (isNotBlank(sour)) {
|
String[] temps = sour.split(splitPatten);
|
for (String string : temps) {
|
list.add(Long.parseLong(string));
|
}
|
}
|
return list;
|
}
|
|
|
/**
|
* 检测temp包含多个参数
|
*
|
* @param temp
|
* @param cons
|
* @return
|
*/
|
public static boolean checkContainMore(String temp, String... cons) {
|
if (temp == null) {
|
return false;
|
}
|
for (String con : cons) {
|
if (temp.contains(con)) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
/**
|
* 将字符串转换为整形
|
*
|
* @param str
|
* @return
|
*/
|
public static int stringToInt(String str) {
|
|
if (StringUtils.isBlank(str)) {
|
return 0;
|
}
|
try {
|
return Integer.valueOf(str).intValue();
|
} catch (Exception e) {
|
return 0;
|
}
|
}
|
|
|
/**
|
* 将文字转为汉语拼音
|
*
|
* @param chineselanguage 要转成拼音的中文
|
*/
|
public static String toHanyuPinyin(String chineseStr) {
|
|
char[] cl_chars = chineseStr.trim().toCharArray();
|
String hanyupinyin = "";
|
HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
|
defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);// 输出拼音全部小写
|
defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);// 不带声调
|
defaultFormat.setVCharType(HanyuPinyinVCharType.WITH_V);
|
try {
|
for (int i = 0; i < cl_chars.length; i++) {
|
if (String.valueOf(cl_chars[i]).matches("[\u4e00-\u9fa5]+")) {// 如果字符是中文,则将中文转为汉语拼音
|
String py = PinyinHelper.toHanyuPinyinStringArray(cl_chars[i], defaultFormat)[0];
|
hanyupinyin += py;
|
} else {// 如果字符不是中文,则不转换
|
if (StringUtils.isNotBlank(cl_chars[i] + "") && !isSpecialChar(cl_chars[i] + "")) {
|
hanyupinyin += cl_chars[i];
|
}
|
|
}
|
}
|
} catch (BadHanyuPinyinOutputFormatCombination e) {
|
throw new GlobleException("助记码生成错误" + e.getMessage());
|
}
|
return hanyupinyin;
|
}
|
|
|
/**
|
* 将首字母转汉语拼音
|
*
|
* @param chineselanguage 要转成拼音的中文
|
*/
|
public static String toHeadWordHanyuPinyin(String chineseStr) {
|
|
char[] cl_chars = chineseStr.trim().toCharArray();
|
String hanyupinyin = "";
|
HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
|
defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);// 输出拼音全部小写
|
defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);// 不带声调
|
defaultFormat.setVCharType(HanyuPinyinVCharType.WITH_V);
|
try {
|
for (int i = 0; i < cl_chars.length; i++) {
|
if (String.valueOf(cl_chars[i]).matches("[\u4e00-\u9fa5]+")) {// 如果字符是中文,则将中文转为汉语拼音
|
String py = PinyinHelper.toHanyuPinyinStringArray(cl_chars[i], defaultFormat)[0];
|
hanyupinyin += py.substring(0,1);
|
} else {// 如果字符不是中文,则不转换
|
if (StringUtils.isNotBlank(cl_chars[i] + "") && !isSpecialChar(cl_chars[i] + "")) {
|
hanyupinyin += cl_chars[i];
|
}
|
|
}
|
}
|
} catch (BadHanyuPinyinOutputFormatCombination e) {
|
throw new GlobleException("助记码生成错误" + e.getMessage());
|
}
|
return hanyupinyin;
|
}
|
|
|
|
|
/**
|
* 判断是否含有特殊字符
|
*
|
* @param str
|
* @return true为包含，false为不包含
|
*/
|
public static boolean isSpecialChar(String str) {
|
|
String regEx = "[ -_`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？]|\n|\r|\t";
|
Pattern p = Pattern.compile(regEx);
|
Matcher m = p.matcher(str);
|
return m.find();
|
}
|
|
public static boolean isStartWithNumber(String str) {
|
Pattern pattern = Pattern.compile("[0-9]*");
|
Matcher isNum = pattern.matcher(str.charAt(0) + "");
|
if (!isNum.matches()) {
|
return false;
|
}
|
return true;
|
}
|
|
|
|
}
|
