String工具类

public class StringUtils extends org.apache.commons.lang3.StringUtils {
	private final static int delta = 0x9fa5 - 0x4e00 + 1;

	/**
	 * 随机获取UUID字符串(无中划线)
	 * 
	 * @return UUID字符串
	 */
	public static String getUUID() {
		String uuid = UUID.randomUUID().toString();
		return uuid.substring(0, 8) + uuid.substring(9, 13) + uuid.substring(14, 18) + uuid.substring(19, 23) + uuid.substring(24);
	}

	/**
	 * 生成随机主键ID
	 * 
	 * @return 主键ID
	 */
	public static String generateNumber() {
		SimpleDateFormat sf = new SimpleDateFormat("MMddHHmmssSSS");
		return sf.format(new Date()) + RandomStringUtils.randomNumeric(5);
	}

	/**
	 * 随机获取字符串
	 * 
	 * @param length
	 *            随机字符串长度
	 * 
	 * @return 随机字符串
	 */
	public static String getRandomString(int length) {
		if (length <= 0) {
			return "";
		}
		char[] randomChar = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', 'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'z', 'x', 'c', 'v', 'b',
				'n', 'm' };
		Random random = new Random();
		StringBuffer stringBuffer = new StringBuffer();
		for (int i = 0; i < length; i++) {
			stringBuffer.append(randomChar[Math.abs(random.nextInt()) % randomChar.length]);
		}
		return stringBuffer.toString();
	}

	/**
	 * 根据指定长度 分隔字符串
	 * 
	 * @param str
	 *            需要处理的字符串
	 * @param length
	 *            分隔长度
	 * 
	 * @return 字符串集合
	 */
	public static List<String> splitString(String str, int length) {
		List<String> list = new ArrayList<String>();
		for (int i = 0; i < str.length(); i += length) {
			int endIndex = i + length;
			if (endIndex <= str.length()) {
				list.add(str.substring(i, i + length));
			} else {
				list.add(str.substring(i, str.length() - 1));
			}
		}
		return list;
	}

	/**
	 * 将字符串List转化为字符串，以分隔符间隔.
	 * 
	 * @param list
	 *            需要处理的List.
	 * 
	 * @param separator
	 *            分隔符.
	 * 
	 * @return 转化后的字符串
	 */
	public static String toString(List<String> list, String separator) {
		StringBuffer stringBuffer = new StringBuffer();
		for (String str : list) {
			stringBuffer.append(separator + str);
		}
		stringBuffer.deleteCharAt(0);
		return stringBuffer.toString();
	}

	/**
	 * 判断目标字符串包含在指定数组中
	 * 
	 * @param searchStr
	 *            目标字符串
	 * @param values
	 *            指定数组
	 * @return 包含则返回true
	 */
	public static boolean inArray(final String searchStr, final String... values) {
		boolean inArray = false;
		if (values != null) {
			for (String value : values) {
				if (searchStr != null && searchStr.equals(value)) {
					inArray = true;
					break;
				}
			}
		}
		return inArray;
	}

	/**
	 * 判断目标字符串不包含在指定数组中
	 * 
	 * @param searchStr
	 *            目标字符串
	 * @param values
	 *            指定数组
	 * @return 不包含则返回true
	 */
	public static boolean notInArray(final String searchStr, final String... values) {
		boolean notInArray = true;
		for (String value : values) {
			if (searchStr != null && searchStr.equals(value)) {
				notInArray = false;
				break;
			}
		}
		return notInArray;
	}

	/**
	 * 判断字符串以指定前缀开头
	 * 
	 * @param searchStr
	 *            字符串
	 * @param prefixes
	 *            前缀数组
	 * @return 若以指定前缀开头则返回true
	 */
	public static boolean startWith(final String searchStr, final String... prefixes) {
		boolean startWithPrefix = false;
		for (String prefix : prefixes) {
			if (startsWith(searchStr, prefix)) {
				startWithPrefix = true;
				break;
			}
		}
		return startWithPrefix;
	}

	/**
	 * 将集合内容转换为SQL语句的in参数 例如，List包含A,B,C,D共4个参数 转换后得到('A','B','C','D')，可直接用于in参数进行操作
	 * 
	 * @param collection
	 *            参数集合
	 * @return SQL语句的in参数
	 */
	public static String convertToInClause(final Collection<?> collection) {
		StringBuilder builder = new StringBuilder();
		builder.append(" ('");
		builder.append(join(collection, "','"));
		builder.append("') ");
		return builder.toString();
	}

	/**
	 * 将集合内容转换为SQL语句的in参数 例如，Object数组包含A,B,C,D共4个参数 转换后得到('A','B','C','D')，可直接用于in参数进行操作
	 * 
	 * @param params
	 *            参数集合
	 * @return SQL语句的in参数
	 */
	public static String convertToInClause(final Object[] params) {
		StringBuilder builder = new StringBuilder();
		builder.append(" ('");
		builder.append(join(params, "','"));
		builder.append("') ");
		return builder.toString();
	}

	/**
	 * 生成流水号
	 * 
	 * @return 流水号
	 */
	public static String generateNumber(final Date date, final String str) {
		SimpleDateFormat sf = new SimpleDateFormat("HHmmssSSS");
		return str + sf.format(date) + RandomStringUtils.randomNumeric(4);
	}

	/**
	 * 将排序Map转换为字符串
	 * 
	 * @param sortMap
	 *            排序Map
	 * @return 排序字符串
	 */
	public static String converSortMapToString(final Map<String, String> sortMap) {
		boolean hasSorts = false;
		List<String> list = new ArrayList<String>();
		for (Map.Entry<String, String> entry : sortMap.entrySet()) {
			hasSorts = true;
			list.add(entry.getKey() + " " + entry.getValue());
		}
		if (hasSorts) {
			return " order by " + join(list, ",") + " ";
		} else {
			return EMPTY;
		}
	}

	/**
	 * 替换单引号，防止SQL注入 注意，MySQL的单引号转义为\'，而SQLServer的为''
	 * 
	 * @param object
	 *            原字符串
	 * @return 替换之后的字符串
	 */
	public static Object replaceSingleQuote(final Object object) {
		if (object != null) {
			if (object instanceof String) {
				return replace((String) object, "'", "\\'");
			} else {
				return object;
			}
		} else {
			return EMPTY;
		}
	}

	/**
	 * 按照开始索引和指定长度截取字符串 双字节字符的长度是2
	 * 
	 * @param str
	 *            字符串
	 * @param startIndex
	 *            开始索引
	 * @param length
	 *            指定长度
	 * @return 截取后的字符串
	 */
	public static String unicodeSubstring(String str, int startIndex, int length, boolean trim) {
		if (str == null) {
			return EMPTY;
		} else {
			byte[] destBytes = new byte[str.getBytes().length - startIndex];
			System.arraycopy(str.getBytes(), startIndex, destBytes, 0, str.getBytes().length - startIndex);
			char[] chars = new String(destBytes).toCharArray();
			int destLength = 0;
			StringBuilder builder = new StringBuilder();
			for (int i = 0; (i < chars.length && destLength < length); i++) {
				String temp = String.valueOf(chars[i]);
				destLength += temp.getBytes().length;
				builder.append(chars[i]);
			}
			return (trim == true) ? trimToEmpty(builder.toString()) : builder.toString();
		}
	}

	/**
	 * 根据指定的长度，取得字符串ISO编码的长度
	 * 
	 * @param source
	 *            源字符串
	 * @param length
	 *            指定的长度，双字节字符长度按2计算
	 * @return 字符串的长度
	 */
	public static int getIsoLength(String source, int length) {
		char[] chars = source.toCharArray();
		StringBuilder builder = new StringBuilder();
		int count = 0;
		for (int i = 0; i < chars.length; i++) {
			if ((int) chars[i] > 256) {
				builder.append(chars[i]);
				count += 2;
			} else {
				builder.append(chars[i]);
				count += 1;
			}
			if (count == length) {
				break;
			}
		}
		return builder.toString().length();
	}

	/**
	 * 将金额转化为人民币大写形式 本方法最大处理范围到千亿
	 * 
	 * @param value
	 *            金额
	 * @return 大写形式
	 */
	public static String convertToWords(double value) {
		char[] hunit = { '拾', '佰', '仟' };
		char[] vunit = { '万', '亿' };
		char[] digit = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' };
		long midVal = (long) (value * 100); // 转化成整形
		if (midVal < 10L) {
			if (midVal == 0L) {
				return "零圆整";
			} else {
				return "零圆零角" + digit[String.valueOf(midVal).charAt(0) - '0'] + "分";
			}
		}
		String valStr = String.valueOf(midVal); // 转化成字符串
		String head = valStr.substring(0, valStr.length() - 2); // 取整数部分
		String rail = valStr.substring(valStr.length() - 2); // 取小数部分

		String prefix = EMPTY; // 整数部分转化的结果
		String suffix = EMPTY; // 小数部分转化的结果
		// 处理小数点后面的数
		if ("00".equals(rail)) { // 如果小数部分为0
			suffix = "整";
		} else {
			if (rail.charAt(1) == '0') {
				suffix = digit[rail.charAt(0) - '0'] + "角整"; // 如果没有分，则将角转换出来
			} else {
				suffix = digit[rail.charAt(0) - '0'] + "角" + digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来
			}
		}
		// 处理小数点前面的数
		char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组
		char zero = '0'; // 标志'0'表示出现过0
		byte zeroSerNum = 0; // 连续出现0的次数
		for (int i = 0; i < chDig.length; i++) {
			int idx = (chDig.length - i - 1) % 4; // 取段内位置
			int vidx = (chDig.length - i - 1) / 4; // 取段位置
			if (chDig[i] == '0') { // 如果当前字符是0
				zeroSerNum++; // 连续0次数递增
				if (zero == '0') { // 标志
					zero = digit[0];
				} else if (idx == 0 && vidx > 0 && zeroSerNum < 4) {
					prefix += vunit[vidx - 1];
					zero = '0';
				}
				continue;
			}
			zeroSerNum = 0; // 连续0次数清零
			if (zero != '0') { // 如果标志不为0,则加上,例如万,亿什么的
				prefix += zero;
				zero = '0';
			}
			prefix += digit[chDig[i] - '0']; // 转化该数字表示
			if (idx > 0)
				prefix += hunit[idx - 1];
			if (idx == 0 && vidx > 0) {
				prefix += vunit[vidx - 1]; // 段结束位置应该加上段名如万,亿
			}
		}

		if (prefix.length() > 0) {
			prefix += '圆'; // 如果整数部分存在,则有圆的字样
		}
		return prefix + suffix; // 返回正确表示
	}

	/**
	 * 解析金额信息
	 * 
	 * @param input
	 *            未解析的金额信息，例如(0000008577代表85.77元)
	 * @return 解析好的金额信息(返回85.77)
	 */
	public static double parseMoney(String input) {
		try {
			double money = Double.parseDouble(input) / 100;
			return money;
		} catch (NumberFormatException e) {
			return 0.0;
		}
	}

	/**
	 * 判断一个字符串是否可转换为Double型
	 */
	public static boolean isDouble(final String str) {
		try {
			Double.parseDouble(str);
			return true;
		} catch (Exception e) {
			return false;
		}
	}

	/**
	 * 判断一个字符串是数字 注意，isNumeric("") 返回的结果为true，所以必须加上非空判断
	 */
	public static boolean isNumeric(final String str) {
		return isNotBlank(str) && org.apache.commons.lang3.StringUtils.isNumeric(str);
	}

	/**
	 * 将属性名转换为数据库的列名 其中，将大写字母转换为下划线加大写字母
	 * 
	 * @param name
	 */
	public static String underscoreName(String name) {
		StringBuilder result = new StringBuilder();
		if (name != null && name.length() > 0) {
			result.append(name.substring(0, 1).toLowerCase());
			for (int i = 1; i < name.length(); i++) {
				String s = name.substring(i, i + 1);
				if (Character.isLetter(s.charAt(0)) && s.equals(s.toUpperCase())) {
					result.append("_");
					result.append(s.toLowerCase());
				} else {
					result.append(s);
				}
			}
		}
		return result.toString();
	}

	/**
	 * 随机生成汉字
	 * 
	 * @param count
	 *            生成个数
	 * @return 汉字字符串
	 */
	public static String getRandomHanzi(int count) {
		if (count < 1) {
			throw new IllegalArgumentException("输入参数有误，至少需产生一个汉字。");
		}
		StringBuilder builder = new StringBuilder();
		Random random = new Random();
		for (int i = 0; i < count; i++) {
			builder.append((char) (0x4e00 + random.nextInt(delta)));
		}
		return builder.toString();
	}