org.voovan.tools.TString Maven / Gradle / Ivy

package org.voovan.tools;

import org.voovan.Global;
import org.voovan.tools.json.JSON;
import org.voovan.tools.log.Logger;
import org.voovan.tools.reflect.TReflect;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadLocalRandom;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * String 工具类
 *
 * @author helyho
 * 
 * Voovan Framework80797d4b533dc83bb73457eb5194d13a45779258eaf3a2c07f041a98b329f79d.
 * WebSite: https://github.com/helyho/Voovan
 * Licence: Apache v2 License
 */
public class TString {

	private static Map regexPattern = new ConcurrentHashMap();

	/**
	 * 单词首字母大写
	 *
	 * @param source 字符串
	 * @return 首字母大写后的字符串
	 */
	public static String upperCaseHead(String source) {
		if (source == null) {
			return null;
		}
		char[] charArray = source.toCharArray();
		charArray[0] = Character.toUpperCase(charArray[0]);
		return new String(charArray);
	}


	/**
	 * 移除字符串前缀
	 *
	 * @param source 目标字符串
	 * @return 移除第一个字节后的字符串
	 */
	public static String removePrefix(String source) {
		if (source == null) {
			return null;
		}
		return source.substring(1, source.length());
	}

	/**
	 * 移除字符串后缀
	 *
	 * @param source 目标字符串
	 * @return 移除最后一个字节后的字符串
	 */
	public static String removeSuffix(String source) {
		if (source == null) {
			return null;
		}

		if (source.isEmpty()) {
			return source;
		}
		return source.substring(0, source.length() - 1);
	}

	/**
	 * 左补齐
	 *
	 * @param source 目标字符串
	 * @param len    补齐后字符串的长度
	 * @param c      用于补齐的字符串
	 * @return 补齐后的字符串
	 */
	public static String leftPad(String source, int len, char c) {
		if (source == null) {
			source = "";
		}
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < len - source.length(); i++) {
			sb.append(c);
		}
		return sb.append(source).toString();
	}

	/**
	 * 右补齐
	 *
	 * @param source 目标字符串
	 * @param len    补齐后字符串的长度
	 * @param c      用于补齐的字符串
	 * @return 补齐后的字符串
	 */
	public static String rightPad(String source, int len, char c) {
		if (source == null) {
			source = "";
		}
		StringBuffer sb = new StringBuffer();
		sb.append(source);
		for (int i = 0; i < len - source.length(); i++) {
			sb.append(c);
		}
		return sb.toString();
	}

	/**
	 * 判断是否是指定进制的数字字符串
	 *
	 * @param numberString 目标字符串
	 * @param radix        进制
	 * @return 是否是指定进制的数字字符串
	 */
	public static boolean isNumber(String numberString, int radix) {
		if (numberString == null) {
			return false;
		}

		try {
			Integer.parseInt(numberString, radix);
			return true;
		} catch (Exception e) {
			return false;
		}
	}

	/**
	 * 判断是否是整形数
	 *
	 * @param integerString 数字字符串
	 * @return 是否是整形数
	 */
	public static boolean isInteger(String integerString) {
		if (integerString != null && regexMatch(integerString, "^-?[0-9]\\d*$") > 0) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 判断是否是浮点数
	 *
	 * @param decimalString 浮点数字符串
	 * @return 是否是浮点数
	 */
	public static boolean isDecimal(String decimalString) {
		if (decimalString != null && regexMatch(decimalString, "^-?\\d+\\.\\d+$") > 0) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 判断是否是布尔值
	 *
	 * @param booleanString 布尔值字符串
	 * @return 是否是布尔值
	 */
	public static boolean isBoolean(String booleanString) {
		if ("true".equalsIgnoreCase(booleanString) || "false".equalsIgnoreCase(booleanString)) {
			return true;
		} else {
			return false;
		}
	}

	private static Pattern getCachedPattern(String regex, Integer flags) {
		Pattern pattern = null;
		flags = flags == null ? 0 : flags;
		pattern = regexPattern.get(regex.hashCode());
		if (pattern==null) {
			pattern = Pattern.compile(regex, flags);
			regexPattern.put(regex.hashCode(), pattern);
		}
		return pattern;
	}

	/**
	 * 执行正则运算
	 *
	 * @param source 目标字符串
	 * @param regex  正则表达式
	 * @return Matcher对象
	 */
	public static Matcher doRegex(String source, String regex) {
		return doRegex(source, regex, 0);
	}

	/**
	 * 执行正则运算
	 *
	 * @param source 目标字符串
	 * @param regex  正则表达式
	 * @param flags  正则匹配标记 CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE, CANON_EQ, UNIX_LINES, LITERAL, UNICODE_CHARACTER_CLASS, COMMENTS
	 * @return Matcher对象
	 */
	public static Matcher doRegex(String source, String regex, Integer flags) {
		if (source == null) {
			return null;
		}

		Pattern pattern = getCachedPattern(regex, flags);
		Matcher matcher = pattern.matcher(source);
		if (matcher.find()) {
			return matcher;
		} else {
			return null;
		}
	}

	/**
	 * 正则表达式查找
	 * 匹配的被提取出来做数组
	 *
	 * @param source 目标字符串
	 * @param regex  正则表达式
	 * @return 匹配的字符串数组
	 */
	public static String[] searchByRegex(String source, String regex) {
		return searchByRegex(source, regex, 0);
	}

	/**
	 * 正则表达式查找
	 * 匹配的被提取出来做数组
	 *
	 * @param source 目标字符串
	 * @param regex  正则表达式
	 * @param flags  正则匹配标记 CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE, CANON_EQ, UNIX_LINES, LITERAL, UNICODE_CHARACTER_CLASS, COMMENTS
	 * @return 匹配的字符串数组
	 */
	public static String[] searchByRegex(String source, String regex, Integer flags) {
		if (source == null) {
			return null;
		}

		ArrayList result = new ArrayList();

		Matcher matcher = doRegex(source, regex, flags);

		if (matcher != null) {
			do {
				result.add(matcher.group());
			} while (matcher.find());
		}
		return result.toArray(new String[0]);
	}

	/**
	 * 正则匹配
	 *
	 * @param source 目标字符串
	 * @param regex  正则表达式
	 * @return 正则搜索后得到的匹配数量
	 */
	public static int regexMatch(String source, String regex) {
		return regexMatch(source, regex, 0);
	}

	/**
	 * 正则匹配
	 *
	 * @param source 目标字符串
	 * @param regex  正则表达式
	 * @param flags  正则匹配标记 CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE, CANON_EQ, UNIX_LINES, LITERAL, UNICODE_CHARACTER_CLASS, COMMENTS
	 * @return 正则搜索后得到的匹配数量
	 */
	public static int regexMatch(String source, String regex, Integer flags) {
		Matcher matcher = doRegex(source, regex, flags);

		int count = 0;
		if (matcher != null) {
			do {
				count++;
			} while (matcher.find());
		}
		return count;
	}

	/**
	 * 快速字符串替换算法
	 * 		默认正在 flag = 0, quoteReplacement = true
	 * @param source      源字符串
	 * @param regex       正则字符串
	 * @param replacement 替换字符串
	 * @return 替换后的字符串
	 */
	public static String fastReplaceAll(String source, String regex, String replacement) {
		return fastReplaceAll(source, regex, replacement, 0, true);
	}

	/**
	 * 快速字符串替换算法
	 * 		默认正在 flag = 0
	 * @param source      源字符串
	 * @param regex       正则字符串
	 * @param replacement 替换字符串
	 * @param quoteReplacement 对 replacement 是否进行转移
	 * @return 替换后的字符串
	 */
	public static String fastReplaceAll(String source, String regex, String replacement, boolean quoteReplacement) {
		return fastReplaceAll(source, regex, replacement, 0, quoteReplacement);
	}

	/**
	 * 快速字符串替换算法
	 *
	 * @param source      源字符串
	 * @param regex       正则字符串
	 * @param replacement 替换字符串
	 * @param flags  	  正则匹配标记 CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE, CANON_EQ, UNIX_LINES, LITERAL, UNICODE_CHARACTER_CLASS, COMMENTS
	 * @param quoteReplacement 对 replacement 是否进行转移
	 * @return 替换后的字符串
	 */
	public static String fastReplaceAll(String source, String regex, String replacement, Integer flags, boolean quoteReplacement) {
		Pattern pattern = getCachedPattern(regex, flags);
		if(quoteReplacement) {
			replacement = Matcher.quoteReplacement(replacement);
		}
		return pattern.matcher(source).replaceAll(replacement);
	}


	/**
	 * 快速字符串替换算法
	 * 		默认正在 flag = 0, quoteReplacement = true
	 * @param source      源字符串
	 * @param regex       正则字符串
	 * @param replacement 替换字符串
	 * @return 替换后的字符串
	 */
	public static String fastReplaceFirst(String source, String regex, String replacement) {
		return fastReplaceFirst(source, regex, replacement, 0, true);
	}

	/**
	 * 快速字符串替换算法
	 * 		默认正在 flag = 0
	 * @param source      源字符串
	 * @param regex       正则字符串
	 * @param replacement 替换字符串
	 * @param quoteReplacement 对 replacement 是否进行转移
	 * @return 替换后的字符串
	 */
	public static String fastReplaceFirst(String source, String regex, String replacement, boolean quoteReplacement) {
		return fastReplaceFirst(source, regex, replacement, 0, quoteReplacement);
	}

	/**
	 * 快速字符串替换算法
	 *
	 * @param source      源字符串
	 * @param regex       正则字符串
	 * @param replacement 替换字符串
	 * @param flags  	  正则匹配标记 CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE, CANON_EQ, UNIX_LINES, LITERAL, UNICODE_CHARACTER_CLASS, COMMENTS
	 * @param quoteReplacement 对 replacement 是否进行转移
	 * @return 替换后的字符串
	 */
	public static String fastReplaceFirst(String source, String regex, String replacement, Integer flags, boolean quoteReplacement) {
		Pattern pattern = getCachedPattern(regex, flags);
		if(quoteReplacement) {
			replacement = Matcher.quoteReplacement(replacement);
		}
		return pattern.matcher(source).replaceFirst(replacement);
	}

	/**
	 * 判断字符串空指针或者内容为空
	 *
	 * @param source 字符串
	 * @return 是否是空指针或者内容为空
	 */
	public static boolean isNullOrEmpty(String source) {
		if (source == null || source.isEmpty()) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 按照标识符 Map 进行替换
	 *
	 * @param source 源字符串,标识符使用"{标识}"进行包裹,这些标识符将会被替换
	 * @param tokens 标识符 Map, 包含匹配字符串和替换字符串
	 * @return 替换后的字符串
	 */
	public static String tokenReplace(String source, Map tokens) {
		if (source == null) {
			return null;
		}

		for (Entry entry : tokens.entrySet()) {
			String value = entry.getValue() == null ? "null" : entry.getValue().toString();
			source = oneTokenReplace(source, entry.getKey(), value);
		}
		return source;
	}

	/**
	 * 按照标识符 Map 进行替换
	 *
	 * @param source 源字符串,标识符使用"{标识}"进行包裹,这些标识符将会被替换
	 * @param list   数据 List 集合
	 * @return 替换后的字符串
	 */
	public static String tokenReplace(String source, List