Java工具类

张军 581 0
package zj.java.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.log4j.Logger;

import com.alibaba.fastjson.JSON;

import zj.check.util.CheckUtil;
import zj.common.exception.ServiceException;
import zj.date.util.DateUtil;
import zj.type.TypeUtil;

/**
 * java工具类
 * 
 * @version 1.00 (2014.09.15)
 * @author SHNKCS 张军 {@link <a target=_blank href="http://www.shanghaijiadun.com">上海加盾信息科技有限公司</a>&nbsp;&nbsp;&nbsp;&nbsp;<a target=_blank href="http://www.zhangjunbk.com">张军个人网站</a>&nbsp;&nbsp;&nbsp;&nbsp;<a target=_blank href="http://user.qzone.qq.com/360901061/">张军QQ空间</a>}
 */
public class JavaUtil implements Serializable {
	private static final long serialVersionUID = 1L;
	private transient static final Logger log = Logger.getLogger(JavaUtil.class);
	/**
	 * 单位进位,中文默认为4位即(万、亿)
	 */
	public static int UNIT_STEP = 4;

	/**
	 * 单位
	 */
	public static String[] CN_UNITS = new String[] { "个", "十", "百", "千", "万", "十", "百", "千", "亿", "十", "百", "千", "万" };
	/**
	 * 汉字
	 */
	public static String[] CN_CHARS = new String[] { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };

	/**
	 * 打印json
	 * 
	 * @param json
	 */
	@SuppressWarnings("unchecked")
	public static Map<String, Object> parseMap(String json) {
		return parseJson(json, Map.class);
	}

	/**
	 * 打印json
	 * 
	 * @param json
	 */
	public static <T> T parseJson(String json, Class<T> clz) {
		T result = JSON.parseObject(json, clz);
		log.debug("json返回结果------------>");
		log.debug(JSON.toJSONString(result, true));
		return result;
	}

	/**
	 * 获取系统换行符号
	 * 
	 * @return
	 */
	public static String getLineBreak() {
		if (JavaUtil.isWindows()) {
			return "\r\n";
		} else if (JavaUtil.isMac()) {
			return "\r";
		} else {
			return "\n";
		}
	}

	/**
	 * 分割email地址,转换成一行
	 * 
	 * @param p_emails
	 *            email地址
	 */
	public static String emailSplitToOneline(String p_emails) {
		return emailSplitToOneline(p_emails, ";");
	}

	/**
	 * 分割email地址,转换成一行
	 * 
	 * @param p_emails
	 *            email地址
	 */
	public static String emailSplitToOneline(String p_emails, String split) {
		// String s = "a; bbcdd55 \r\nb\r\nc\r\nd";
		String[] v_emails1 = JavaUtil.split(p_emails, getLineBreak());
		String r_emails = "";
		for (String v_email1 : v_emails1) {
			v_email1 = JavaUtil.trim(v_email1);
			if (CheckUtil.isNull(v_email1)) {
				continue;
			}
			String[] v_emails2 = JavaUtil.split(v_email1, split);
			for (String v_email2 : v_emails2) {
				v_email2 = JavaUtil.trim(v_email2);
				if (CheckUtil.isNull(v_email1)) {
					continue;
				}
				if (CheckUtil.isNotNull(r_emails)) {
					r_emails += split;
				}
				r_emails += v_email2;
			}
		}
		return r_emails;
	}

	/**
	 * 是否是windows
	 * 
	 * @return
	 */
	public static boolean isWindows() {
		try {
			String osName = System.getProperty("os.name");
			return JavaUtil.toLowerCase(osName).indexOf("windows") != -1;
		} catch (Exception e) {
			return true;
		}
	}

	/**
	 * 是否是mac系统
	 * 
	 * @return
	 */
	public static boolean isMac() {
		try {
			String osName = System.getProperty("os.name");
			return JavaUtil.toLowerCase(osName).indexOf("mac") != -1;
		} catch (Exception e) {
			return true;
		}
	}

	/**
	 * 支持到12位
	 *
	 * @param numberStr
	 *            中文数字
	 * @return int 数字
	 */
	public static int getIntegerByStr(String numberStr) {

		// 返回结果
		int sum = 0;

		// null或空串直接返回
		if (numberStr == null || ("").equals(numberStr)) {
			return sum;
		}

		// 过亿的数字处理
		if (numberStr.indexOf("亿") > 0) {
			String currentNumberStr = numberStr.substring(0, numberStr.indexOf("亿"));
			int currentNumber = doByStr(currentNumberStr);
			sum += currentNumber * Math.pow(10, 8);
			numberStr = numberStr.substring(numberStr.indexOf("亿") + 1);
		}

		// 过万的数字处理
		if (numberStr.indexOf("万") > 0) {
			String currentNumberStr = numberStr.substring(0, numberStr.indexOf("万"));
			int currentNumber = doByStr(currentNumberStr);
			sum += currentNumber * Math.pow(10, 4);
			numberStr = numberStr.substring(numberStr.indexOf("万") + 1);
		}

		// 小于万的数字处理
		if (!("").equals(numberStr)) {
			int currentNumber = doByStr(numberStr);
			sum += currentNumber;
		}

		return sum;
	}

	/**
	 * 把亿、万分开每4位一个单元,解析并获取到数据
	 * 
	 * @param testNumber
	 * @return
	 */
	public static int doByStr(String testNumber) {
		// 返回结果
		int sum = 0;

		// null或空串直接返回
		if (testNumber == null || ("").equals(testNumber)) {
			return sum;
		}

		// 获取到千位数
		if (testNumber.indexOf("千") > 0) {
			String currentNumberStr = testNumber.substring(0, testNumber.indexOf("千"));
			sum += doByStrReplace(currentNumberStr) * Math.pow(10, 3);
			testNumber = testNumber.substring(testNumber.indexOf("千") + 1);
		}

		// 获取到百位数
		if (testNumber.indexOf("百") > 0) {
			String currentNumberStr = testNumber.substring(0, testNumber.indexOf("百"));
			sum += doByStrReplace(currentNumberStr) * Math.pow(10, 2);
			testNumber = testNumber.substring(testNumber.indexOf("百") + 1);
		}

		// 对于特殊情况处理 比如10-19是个数字,十五转化为一十五,然后再进行处理
		if (testNumber.indexOf("十") == 0) {
			testNumber = "一" + testNumber;
		}

		// 获取到十位数
		if (testNumber.indexOf("十") > 0) {
			String currentNumberStr = testNumber.substring(0, testNumber.indexOf("十"));
			sum += doByStrReplace(currentNumberStr) * Math.pow(10, 1);
			testNumber = testNumber.substring(testNumber.indexOf("十") + 1);
		}

		// 获取到个位数
		if (!("").equals(testNumber)) {
			sum += doByStrReplace(testNumber.replaceAll("零", ""));
		}

		return sum;
	}

	public static int doByStrReplace(String replaceNumber) {
		switch (replaceNumber) {
		case "一":
			return 1;
		case "二":
			return 2;
		case "三":
			return 3;
		case "四":
			return 4;
		case "五":
			return 5;
		case "六":
			return 6;
		case "七":
			return 7;
		case "八":
			return 8;
		case "九":
			return 9;
		case "零":
			return 0;
		default:
			throw new ServiceException("无法解析大写数字【" + replaceNumber + "】");
		}
	}

	/**
	 * 数字转大写,仅仅转大写
	 * 
	 * @param pnum
	 *            数字字符串,可带其它字符
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return
	 */
	public static String numToCnChar(String pnum) {
		char[] cnumAry = pnum.toCharArray();
		String snumNew = "";
		for (char cnum : cnumAry) {
			String snum = objToStr(cnum);
			if (CheckUtil.isPlusNum(snum)) {
				snumNew += CN_CHARS[TypeUtil.Primitive.intValue(snum)];
			} else {
				snumNew += snum;
			}
		}
		return snumNew;
	}

	/**
	 * 数字转大写日期(只支持4位数字年或2位数字月日)
	 * 
	 * @see 年、月、日分别调用
	 * @param pnum
	 *            数字
	 * @param decimal
	 *            是否是十进位,默认false,如果是true,则12-》十二
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return
	 */
	public static String numToCnCharDate(int pnum) {
		String rnum = numToCnChar(JavaUtil.objToStr(pnum));
		if (pnum < 1000) {
			if (pnum == 10) {
				rnum = "十";
			} else if (pnum > 10) {
				if (rnum.startsWith("一")) {
					rnum = "十" + rnum.substring(1);
				} else {
					rnum = rnum.substring(0, 1) + "十" + rnum.substring(1);
				}
			}
		}
		return rnum;
	}

	/**
	 * 数值转换为中文字符串 如2转化为贰
	 */
	public static String numToCn(long num) {
		return numToCn(num, true);
	}

	/**
	 * 数值转换为中文字符串(口语化)
	 * 
	 * @param num
	 *            需要转换的数值
	 * @param isColloquial
	 *            是否口语化。例如12转换为'十二'而不是'一十二'。
	 * @return
	 */
	public static String numToCn(String num, boolean isColloquial) {
		int integer = 0, decimal = 0;
		StringBuffer strs = new StringBuffer(32);
		String[] splitNum = num.split("\\.");
		if (splitNum.length > 0)
			integer = Integer.parseInt(splitNum[0]); // 整数部分
		if (splitNum.length > 1)
			decimal = Integer.parseInt(splitNum[1]); // 小数部分
		String[] result_1 = numConvert(integer, isColloquial);
		for (String str1 : result_1)
			strs.append(str1);
		if (decimal == 0) {// 小数部分为0时
			return strs.toString();
		} else {
			String result_2 = numToCnChar("" + decimal); // 例如5.32,小数部分展示三二,而不是三十二
			strs.append("点");
			strs.append(result_2);
			return strs.toString();
		}
	}

	/**
	 * 对于int,long类型的数据处理
	 * 
	 * @param num
	 *            需要转换的数值
	 * @param isColloquial
	 *            是否口语化。例如12转换为'十二'而不是'一十二'。
	 * @return
	 */
	public static String numToCn(long num, boolean isColloquial) {
		String[] result = numConvert(num, isColloquial);
		StringBuffer strs = new StringBuffer(32);
		for (String str : result) {
			strs.append(str);
		}
		return strs.toString();
	}

	/**
	 * 将数值转换为中文
	 * 
	 * @param num
	 *            需要转换的数值
	 * @param isColloquial
	 *            是否口语化。例如12转换为'十二'而不是'一十二'。
	 * @return
	 */
	public static String[] numConvert(long num, boolean isColloquial) {
		if (num < 10) {// 10以下直接返回对应汉字
			return new String[] { CN_CHARS[(int) num] };// ASCII2int
		}

		char[] chars = String.valueOf(num).toCharArray();
		if (chars.length > CN_UNITS.length) {// 超过单位表示范围的返回空
			return new String[] {};
		}

		boolean isLastUnitStep = false;// 记录上次单位进位
		ArrayList<String> cnchars = new ArrayList<String>(chars.length * 2);// 创建数组,将数字填入单位对应的位置
		for (int pos = chars.length - 1; pos >= 0; pos--) {// 从低位向高位循环
			char ch = chars[pos];
			String cnChar = CN_CHARS[ch - '0'];// ascii2int 汉字
			int unitPos = chars.length - pos - 1;// 对应的单位坐标
			String cnUnit = CN_UNITS[unitPos];// 单位
			boolean isZero = (ch == '0');// 是否为0
			boolean isZeroLow = (pos + 1 < chars.length && chars[pos + 1] == '0');// 是否低位为0

			boolean isUnitStep = (unitPos >= UNIT_STEP && (unitPos % UNIT_STEP == 0));// 当前位是否需要单位进位

			if (isUnitStep && isLastUnitStep) {// 去除相邻的上一个单位进位
				int size = cnchars.size();
				cnchars.remove(size - 1);
				if (!CN_CHARS[0].equals(cnchars.get(size - 2))) {// 补0
					cnchars.add(CN_CHARS[0]);
				}
			}

			if (isUnitStep || !isZero) {// 单位进位(万、亿),或者非0时加上单位
				cnchars.add(cnUnit);
				isLastUnitStep = isUnitStep;
			}
			if (isZero && (isZeroLow || isUnitStep)) {// 当前位为0低位为0,或者当前位为0并且为单位进位时进行省略
				continue;
			}
			cnchars.add(cnChar);
			isLastUnitStep = false;
		}

		Collections.reverse(cnchars);
		// 清除最后一位的0
		int chSize = cnchars.size();
		String chEnd = cnchars.get(chSize - 1);
		if (CN_CHARS[0].equals(chEnd) || CN_UNITS[0].equals(chEnd)) {
			cnchars.remove(chSize - 1);
		}

		// 口语化处理
		if (isColloquial) {
			String chFirst = cnchars.get(0);
			String chSecond = cnchars.get(1);
			if (chFirst.equals(CN_CHARS[1]) && chSecond.startsWith(CN_UNITS[1])) {// 是否以'一'开头,紧跟'十'
				cnchars.remove(0);
			}
		}
		return cnchars.toArray(new String[] {});
	}

	/**
	 * 检查数据差异
	 * 
	 * @param text
	 *            数字
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return
	 */
	public static <T> List<T> diffColl(Collection<T> c1, Collection<T> c2) {
		List<T> result = new ArrayList<T>();
		try {
			// 添加至去重列表中
			Set<T> allC = new HashSet<T>();
			allC.addAll(c1);
			allC.addAll(c2);
			for (T v : allC) {
				if (c1.contains(v) && c2.contains(v)) {
					// 两个集合中的数据共同包含
				} else {
					// 两个集合中的数据不相同的
					result.add(v);
				}
			}
		} catch (Exception e) {
			throw new ServiceException(e);
		}
		return result;
	}

	/**
	 * DecimalFormat转换数字
	 * 
	 * @param text
	 *            数字
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return
	 */
	public static String covertNumEToString(Object text) {
		return covertNumEToString(text, null);
	}

	/**
	 * DecimalFormat转换数字
	 * 
	 * @param text
	 *            数字
	 * @param format
	 *            格式
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return
	 */
	public static String covertNumEToString(Object text, String format) {
		try {
			if (CheckUtil.isNull(format)) {
				format = "#.##";
			}
			if (!(text instanceof String)) {
				DecimalFormat df = new DecimalFormat(format);
				Double d = Double.parseDouble(df.format(text));
				String sd = df.format(d);
				return sd;
			}
			return objToStr(text);
		} catch (Exception e) {
			throw new ServiceException(e);
		}
	}

	/**
	 * DecimalFormat转换数字
	 * 
	 * @param text
	 *            数字
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return
	 */
	public static String covertToNumSplit(Object text) {
		return covertToNumSplit(text, null);
	}

	/**
	 * DecimalFormat转换数字
	 * 
	 * @param text
	 *            数字
	 * @param format
	 *            格式
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return
	 */
	public static String covertToNumSplit(Object text, String format) {
		try {
			if (CheckUtil.isNull(format)) {
				format = "###,###.##";
			}
			DecimalFormat df = new DecimalFormat(format);
			return df.format(TypeUtil.Primitive.doubleValueNoCatchError(text));
		} catch (Exception e) {
			throw new ServiceException(e);
		}
	}

	/**
	 * 转换数字
	 * 
	 * @param text
	 *            数字
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return
	 */
	public static BigDecimal covertBigDecimal(Object text) {
		String value = JavaUtil.conversionStringToNumber(JavaUtil.trim(JavaUtil.objToStr(text)));
		BigDecimal bvalue = BigDecimal.ZERO;
		if (CheckUtil.isNotNull(value)) {
			try {
				bvalue = new BigDecimal(value);
			} catch (Exception e) {
				// 不做处理
			}
		}
		return bvalue;
	}

	/**
	 * 获取in的字符串
	 * 
	 * @param strs
	 *            字符集合
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return
	 */
	public static String sqlInStr(Collection<String> strs) {
		String rtnStrs = "";
		int i = 0;
		for (String s : strs) {
			if (i != 0)
				rtnStrs += ",";
			rtnStrs += "'" + s + "'";
			i++;
		}
		return rtnStrs;
	}

	/**
	 * 转换文件大小为B、KB、MB、GB
	 * 
	 * @param size
	 *            文件大小
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return
	 */
	public static String convertFileSize(long size) {
		// 转成大数据
		if (size < 1024) {
			// B
			return String.valueOf(size) + "B";
		} else {
			// KB
			BigDecimal b1024 = new BigDecimal(1024);
			BigDecimal tempSize = new BigDecimal(size);
			BigDecimal valueSize = tempSize.divide(b1024, 8, BigDecimal.ROUND_HALF_UP);
			if (valueSize.compareTo(b1024) <= 0) {
				// 如果小于1024
				return valueSize.setScale(2, BigDecimal.ROUND_HALF_UP).toString() + "KB";
			} else {
				// MB
				valueSize = valueSize.divide(b1024, 6, BigDecimal.ROUND_HALF_UP);
				if (valueSize.compareTo(b1024) <= 0) {
					// 如果小于1024
					return valueSize.setScale(2, BigDecimal.ROUND_HALF_UP).toString() + "MB";
				} else {
					// GB
					valueSize = valueSize.divide(b1024, 4, BigDecimal.ROUND_HALF_UP);
					if (valueSize.compareTo(b1024) <= 0) {
						// 如果小于1024
						return valueSize.setScale(2, BigDecimal.ROUND_HALF_UP).toString() + "GB";
					} else {
						// TB
						valueSize = valueSize.divide(b1024, 2, BigDecimal.ROUND_HALF_UP);
						if (valueSize.compareTo(b1024) <= 0) {
							// 如果小于1024
							return valueSize.setScale(2, BigDecimal.ROUND_HALF_UP).toString() + "TB";
						} else {
							// 默认
							return tempSize.toString() + "B";
						}
					}
				}
			}
		}
	}

	/**
	 * 深度拷贝list数据
	 * 
	 * @param src
	 *            源集合
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static <T> List<T> deepCopy(List<T> src) {
		try {
			ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
			ObjectOutputStream out = new ObjectOutputStream(byteOut);
			out.writeObject(src);
			ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
			ObjectInputStream in = new ObjectInputStream(byteIn);
			return (List<T>) in.readObject();
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * 合并两个数组
	 * 
	 * @param first
	 *            第一个数组
	 * @param second
	 *            第二个数组
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return
	 */
	public static <T> T[] concatArray(T[] first, T[] second) {
		T[] result = Arrays.copyOf(first, first.length + second.length);
		System.arraycopy(second, 0, result, first.length, second.length);
		return result;
	}

	// @SuppressWarnings("unchecked")
	// public static <T> T[] concatArray(T[] a, T[] b) {
	// final int alen = a.length;
	// final int blen = b.length;
	// if (alen == 0) {
	// return b;
	// }
	// if (blen == 0) {
	// return a;
	// }
	// final T[] result = (T[]) java.lang.reflect.Array.newInstance(a.getClass().getComponentType(), alen + blen);
	// System.arraycopy(a, 0, result, 0, alen);
	// System.arraycopy(b, 0, result, alen, blen);
	// return result;
	// }
	/**
	 * 合并多个数组
	 * 
	 * @param first
	 *            第一个数组
	 * @param rest
	 *            多个组合
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static <T> T[] concatArrayAll(T[] first, T[]... rest) {
		int totalLength = first.length;
		for (T[] array : rest) {
			totalLength += array.length;
		}
		T[] result = Arrays.copyOf(first, totalLength);
		int offset = first.length;
		for (T[] array : rest) {
			System.arraycopy(array, 0, result, offset, array.length);
			offset += array.length;
		}
		return result;
	}

	/**
	 * 替换字符串
	 * 
	 * @param template
	 *            模板字符串
	 * @param placeholder
	 * @param replacement
	 * @return
	 */
	public static String replaceOnce(String template, String placeholder, String replacement) {
		// System.out.println("varchar($2)".replaceAll("\\$2", "9")+replaceOnce("varchar($2)","$2","6"));
		int loc = template == null ? -1 : template.indexOf(placeholder);
		if (loc < 0) {
			return template;
		} else {
			return new StringBuffer(template.substring(0, loc)).append(replacement).append(template.substring(loc + placeholder.length())).toString();
		}
	}

	/**
	 * 去除text所有空格
	 * 
	 * @param text
	 * @return
	 */
	public static final String trims(String text) {
		if (CheckUtil.isNull(text)) {
			return text;
		}
		String newStr = "";
		char[] chars = text.toCharArray();
		for (char c : chars) {
			String s = JavaUtil.objToStr(c);
			if (CheckUtil.isNull(s)) {
				continue;
			}
			newStr += s;
		}
		return newStr;
	}

	/**
	 * 去除text左右空格
	 * 
	 * @param text
	 * @return
	 */
	public static final String trim(String text) {
		return ltrim(rtrim(text));
	}

	/**
	 * 替换左字符 String d = "b d a e abcd f "; String rs = CommonUtil.ltrimText(d, "a", "b", " d");
	 * 
	 * @param text
	 * @param trimText
	 * @return
	 */
	public static final String ltrimText(final String text, String... trimText) {
		if (text == null) {
			return null;
		}
		if (trimText == null || trimText.length == 0) {
			return ltrim(text);
		}
		int pos = 0;
		for (; pos < text.length(); pos++) {
			boolean notTrimChar = true;
			for (int i = 0; i < trimText.length; i++) {
				notTrimChar &= (trimText[i].indexOf(text.charAt(pos)) < 0);
			}
			if (notTrimChar) {
				break;
			}
		}
		return text.substring(pos);
	}

	/**
	 * 替换右字符
	 * 
	 * @param text
	 * @param trimText
	 * @return
	 */
	public static final String rtrimText(final String text, String... trimText) {
		if (text == null) {
			return null;
		}
		if (trimText == null || trimText.length == 0) {
			return rtrim(text);
		}
		int pos = text.length() - 1;
		for (; pos >= 0; pos--) {
			boolean notTrimChar = true;
			for (int i = 0; i < trimText.length; i++) {
				notTrimChar &= (trimText[i].indexOf(text.charAt(pos)) < 0);
			}
			if (notTrimChar) {
				break;
			}
		}
		return text.substring(0, pos + 1);
	}

	/**
	 * 替换左字符串
	 * 
	 * @param text
	 * @return
	 */
	public static final String ltrim(String text) {
		return ltrim(text, null);
	}

	/**
	 * 替换左字符串
	 * 
	 * @param text
	 * @param trimText
	 * @return
	 */
	public static final String ltrim(String text, String trimText) {
		if (text == null)
			return null;
		if (trimText == null)
			trimText = " ";
		int pos;
		for (pos = 0; pos < text.length() && trimText.indexOf(text.charAt(pos)) >= 0; pos++)
			;
		return text.substring(pos);
	}

	/**
	 * 替换右字符串
	 * 
	 * @param text
	 * @return
	 */
	public static final String rtrim(String text) {
		return rtrim(text, null);
	}

	/**
	 * 替换右字符串
	 * 
	 * @param text
	 * @param trimText
	 * @return
	 */
	public static final String rtrim(String text, String trimText) {
		if (text == null)
			return null;
		if (trimText == null)
			trimText = " ";
		int pos;
		for (pos = text.length() - 1; pos >= 0 && trimText.indexOf(text.charAt(pos)) >= 0; pos--)
			;
		return text.substring(0, pos + 1);
	}

	/**
	 * 分割字符串类
	 * 
	 * @author zhangjun
	 * 
	 */
	public static class SplitConstants {
		public static final String TRIM = "all";
		public static final String NRIM = "none";
		public static final String LTRIM = "left";
		public static final String RTRIM = "right";

		public static final String NO_CASE = "";
		public static final String TO_UPPER_CASE = "0";
		public static final String TO_LOWER_CASE = "1";
	}

	/**
	 * 分割字符串
	 * 
	 * @param str
	 * @param delim
	 * @return
	 */
	public static final String[] split(String str, String delim) {
		return split(str, delim, SplitConstants.TRIM, SplitConstants.NO_CASE);
	}

	/**
	 * 分割字符串
	 * 
	 * @param str
	 * @param delim
	 * @param caseType
	 * @return
	 */
	public static final String[] split(String str, String delim, String caseType) {
		return split(str, delim, SplitConstants.TRIM, caseType);
	}

	/**
	 * 分割字符串
	 * 
	 * @param str
	 * @param delim
	 * @param trim
	 *            去除左右空格
	 * @param caseType
	 * @return
	 */
	public static final String[] split(String str, String delim, String trim, String caseType) {
		String[] arrayStrings;
		try {
			arrayStrings = mySplit(str, delim, trim, caseType);
		} catch (Throwable t) {
			arrayStrings = null;
		}
		if (arrayStrings == null) {
			arrayStrings = new String[0];
		}
		return arrayStrings;

	}

	/**
	 * 分割字符串
	 * 
	 * @param s
	 * @param delimiter
	 * @param trim
	 * @param caseType
	 * @return
	 */
	private static String[] mySplit(String str, String delimiter, String trim, String caseType) {
		int delimiterLength;
		int stringLength = str.length();
		if (delimiter == null || (delimiterLength = delimiter.length()) == 0) {
			return new String[] { str };
		}
		int count;
		int start;
		int end;
		count = 0;
		start = 0;
		while ((end = str.indexOf(delimiter, start)) != -1) {
			count++;
			start = end + delimiterLength;
		}
		count++;
		String[] result = new String[count];
		count = 0;
		start = 0;
		while ((end = str.indexOf(delimiter, start)) != -1) {
			result[count] = getTrimStr(str.substring(start, end), trim, caseType);
			count++;
			start = end + delimiterLength;
		}
		end = stringLength;
		result[count] = getTrimStr(str.substring(start, end), trim, caseType);
		return (result);
	}

	/**
	 * 合并字符串
	 * 
	 * @param str
	 * @param trim
	 * @param caseType
	 * @return
	 */
	private static String getTrimStr(String str, String trim, String caseType) {
		if (SplitConstants.TRIM.equals(trim)) {
			str = str.trim();
		} else if (SplitConstants.LTRIM.equals(trim)) {
			str = ltrim(str);
		} else if (SplitConstants.RTRIM.equals(trim)) {
			str = rtrim(str);
		}
		if (SplitConstants.TO_LOWER_CASE.equals(caseType)) {
			str = str.toLowerCase();
		} else if (SplitConstants.TO_UPPER_CASE.equals(caseType)) {
			str = str.toUpperCase();
		}
		return str;
	}

	/**
	 * 转strs数组为字符串用split分割
	 * 
	 * @param strs
	 * @param split
	 * @return
	 */
	public static String getAryStrs(String[] strs, String split) {
		return getAryStrs(strs, split, "");
	}

	/**
	 * 转split分割的str字符串,转新的分割newSplit,添加在值左右添加addStr字符串
	 * 
	 * @param str
	 * @param split
	 * @param newSplit
	 * @param addStr
	 * @return
	 */
	public static String getAryStrs(String str, String split, String newSplit, String addStr) {
		return getAryStrs(split(str, split), newSplit, addStr);
	}

	/**
	 * 转strs数组为字符串用split分割,添加在值左右添加addStr字符串
	 * 
	 * @param strs
	 * @param split
	 * @param addStr
	 * @return
	 */
	public static String getAryStrs(String[] strs, String split, String addStr) {
		String rtnStrs = "";
		try {
			if (strs.length == 1 && strs[0].equals(""))
				return "";
			for (int i = 0; i < strs.length; i++) {
				if (i != 0)
					rtnStrs += split;
				rtnStrs += addStr + strs[i] + addStr;
			}
		} catch (Exception e) {
			rtnStrs = "";
			log.error(e.getMessage());
		}
		return rtnStrs;
	}

	/**
	 * 返回String
	 * 
	 * @param o
	 * @return
	 */
	public static String objToStr(Object obj) {
		String str = "";
		if (obj == null) {
			return str;
		} else {
			if (obj instanceof Date) {
				str = DateUtil.dateParse((Date) obj, "yyyy-MM-dd HH:mm:ss");
			} else {
				str = obj.toString();
			}
		}
		return str;
	}

	/**
	 * 返回String
	 * 
	 * @param o
	 * @return
	 */
	public static String objToStrNull(Object obj) {
		if (obj == null) {
			return null;
		} else {
			return objToStr(obj);
		}
	}

	/**
	 * 转换成大写
	 * 
	 * @param o
	 * @return
	 */
	public static String toUpperCase(String o) {
		return o == null ? null : o.toUpperCase();
	}

	/**
	 * 转换成小写
	 * 
	 * @param o
	 * @return
	 */
	public static String toLowerCase(String o) {
		return o == null ? null : o.toLowerCase();
	}

	/**
	 * LIST转数组
	 * 
	 * @param list
	 * @param clazz
	 * @return
	 */
	public static <T> T[] listToArray(List<T> list, Class<T> clazz) {
		if (list == null || list.size() == 0)
			return null;
		@SuppressWarnings("unchecked")
		T[] array = (T[]) Array.newInstance(clazz, list.size());
		for (int i = 0; i < array.length; i++) {
			array[i] = list.get(i);
		}
		return array;
	}

	/**
	 * 获取最大长度文字
	 * 
	 * @param text
	 * @param count
	 * @return
	 */
	public static String getMaxText(String text, int count) {
		// 设置文章标题最大值
		if (text == null || text.trim().equals(""))
			return "";
		int maxIndex = -1;
		maxIndex = text.length();
		if (maxIndex > count) {
			return text.substring(0, count) + "...";
		} else {
			return text;
		}
	}

	/**
	 * 转换重复的list集合
	 * 
	 * @param list
	 * @return
	 */
	public static List<Map<Object, List<Object>>> convertRepeatList(List<Map<Object, Object>> list) {
		List<Map<Object, List<Object>>> rtnList = new ArrayList<Map<Object, List<Object>>>();
		Map<Object, Object> newMap = new HashMap<Object, Object>();
		for (Map<Object, Object> map : list) {
			Object key = map.keySet().iterator().next();
			newMap.put(key, null);
		}
		Map<Object, List<Object>> newMaps = null;
		List<Object> newLists = null;
		for (Object key : newMap.keySet()) {
			newMaps = new HashMap<Object, List<Object>>();
			newLists = new ArrayList<Object>();
			for (Map<Object, Object> map : list) {
				Object value2 = map.get(key);
				if (map.containsKey(key)) {
					newLists.add(value2);
				}
			}
			newMaps.put(key, newLists);
			rtnList.add(newMaps);
		}
		return rtnList;
	}

	/**
	 * 获取UUID唯一标识
	 * 
	 * @return
	 */
	public static synchronized String getUUID() {
		// + "-" + System.currentTimeMillis()
		return getUUID("");
	}

	/**
	 * 
	 * @return
	 */
	public static synchronized String getUUID32() {
		// + "-" + System.currentTimeMillis()
		return UUID.randomUUID().toString().replaceAll("-", "");
	}

	/**
	 * 获取UUID唯一标识
	 * 
	 * @return
	 */
	public static synchronized String getUUID(Class<?> cla) {
		return getUUID(cla.getSimpleName());
	}

	/**
	 * 获取UUID唯一标识
	 * 
	 * @return
	 */
	public static synchronized String getUUID(String prefix) {
		String ymdhmss = DateUtil.dateParse(new Date(), "yyyyMMddHHmmssSSS");
		return (CheckUtil.isNull(prefix) ? "id_" + ymdhmss : toLowerCase(prefix) + "_" + ymdhmss) + "_" + getUUID32();
	}

	/**
	 * Object对象换int类型
	 * 
	 * @param o
	 * @return
	 */
	public static int getIntValue(Object o) {
		if (o == null) {
			return 0;
		} else {
			try {
				if (o instanceof BigDecimal) {
					return ((BigDecimal) o).intValue();
				} else if (o instanceof Integer) {
					return ((Integer) o).intValue();
				} else if (o instanceof Long) {
					return ((Long) o).intValue();
				} else if (o instanceof String) {
					return Integer.parseInt(String.valueOf(o));
				} else {
					return Integer.parseInt(o + "");
				}
			} catch (Exception e) {
				log.error(e.getMessage());
				return 0;
			}
		}
	}

	/**
	 * 去除数组中为null或""的值
	 * 
	 * @param values
	 * @return
	 */
	public static String[] aryTrimValue(String[] values) {
		if (values == null) {
			return null;
		} else {
			List<String> valuesLst = new ArrayList<String>();
			for (String value : values) {
				if (CheckUtil.isNotNull(value)) {
					valuesLst.add(value);
				}
			}
			return (String[]) valuesLst.toArray(new String[valuesLst.size()]);
		}
	}

	/**
	 * 提取字符串中的整数字
	 * 
	 * @param txt
	 * @return
	 */
	public static int conversionStringToNum(String txt) {
		try {
			return Integer.parseInt(conversionStringToString("[^0-9]", txt));
		} catch (Exception e) {
			return 0;
		}
	}

	/**
	 * 提取字符串中的数字
	 * 
	 * @param txt
	 * @return
	 */
	public static String conversionStringToNumber(String txt) {
		return conversionStringToString("[^0-9\\.-]", txt);
	}

	/**
	 * 提取字符串中的数字
	 * 
	 * @param txt
	 * @return
	 */
	public static String conversionStringToString(String regEx, String txt) {
		if (CheckUtil.isNull(txt))
			return null;
		// String regEx = "[^0-9]";
		Pattern p = Pattern.compile(regEx);
		Matcher m = p.matcher(txt);
		// 替换非数字字符
		String str = m.replaceAll("").trim();
		return str;
	}

	/**
	 * 取得布尔值
	 * 
	 * @param txt
	 * @return
	 */
	@Deprecated
	public static boolean getBoolean(String txt) {
		try {
			return Boolean.parseBoolean(txt);
		} catch (Exception e) {
			log.error(e.getMessage());
			return false;
		}
	}

	/**
	 * 取得Long值
	 * 
	 * @param txt
	 * @return
	 */
	@Deprecated
	public static long getLong(String txt) {
		try {
			return Long.parseLong(txt);
		} catch (Exception e) {
			log.error(e.getMessage());
			return 0l;
		}
	}

	/**
	 * 获取批量集合值
	 * 
	 * @param batchList
	 *            集合数据
	 * @param batchSize
	 *            每页显示条数
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return 批量集合值
	 */
	public static <T> List<List<T>> getBatchList(List<T> batchList, int batchSize) {
		List<List<T>> batchLists = new ArrayList<List<T>>();
		if (batchSize == 0) {
			return batchLists;
		}
		List<T> tempBatchList = null;
		int mod = batchList.size() % batchSize;
		int remainder = batchList.size() / batchSize;
		for (int i = 0; i < remainder; i++) {
			tempBatchList = new ArrayList<T>();
			for (int j = 1 + batchSize * i; j <= batchSize * (i + 1); j++) {
				tempBatchList.add(batchList.get(j - 1));
			}
			batchLists.add(tempBatchList);
		}
		if (mod != 0) {
			tempBatchList = new ArrayList<T>();
			for (int i = batchSize * remainder; i < batchList.size(); i++) {
				tempBatchList.add(batchList.get(i));
			}
			batchLists.add(tempBatchList);
		}
		return batchLists;
	}

	/**
	 * 获取固定批量集合
	 * 
	 * @param batchList
	 *            集合数据
	 * @param batchSize
	 *            批量集合大小
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return 批量集合
	 */
	public static <T> List<List<T>> getFixedBatchList(List<T> batchList, int batchSize) {
		List<List<T>> batchLists = new ArrayList<List<T>>();
		if (batchSize == 0) {
			return batchLists;
		}
		int count = batchList.size();
		// 每个线程处理的集合数
		int preCount = count / batchSize;
		// 判断是否整除线程数
		int modCount = count % batchSize;
		if (modCount != 0) {
			preCount++;
		}
		// 记录索引
		int index = 0;
		List<T> tempTask = new ArrayList<T>();
		batchLists.add(tempTask);
		for (int i = 0; i < count; i++) {
			T value = batchList.get(i);
			tempTask.add(value);
			if (i != count - 1) {
				// 如果非最后一个元素
				index++;
				// 如果等于计算出来的每页条数
				if (index == preCount) {
					// 实例化集合
					tempTask = new ArrayList<T>();
					batchLists.add(tempTask);
					// 重新开始
					index = 0;
				}
			}
		}
		return batchLists;
	}

	/**
	 * 根据页码条数计算多少页
	 * 
	 * @param total
	 *            总条数
	 * @param rows
	 *            每页显示条数
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return 总页数
	 */
	public static int calcPageCount(int total, int rows) {
		int pageCount = total / rows;
		int mod = total % rows;
		if (mod != 0) {
			pageCount++;
		}
		return pageCount;
	}

	/**
	 * 根据总条数获取固定页数
	 * 
	 * @param total
	 *            总条数
	 * @param rows
	 *            每页显示条数
	 * @param page
	 *            当前页
	 * @param showPageCount
	 *            显示多少页
	 * 
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return 集合对象
	 * @see 开始页:map.get("startPage")
	 * @see 结束页:map.get("pageCount")
	 */
	public static Map<String, Object> calcPageCount(int total, int rows, int page, int showPageCount) {
		int pageCount = calcPageCount(total, rows);
		return calcPageCount(pageCount, page, showPageCount);
	}

	/**
	 * 根据总条数获取固定页数
	 * 
	 * @param pageCount
	 *            总页码
	 * @param page
	 *            当前页
	 * @param showPageCount
	 *            显示多少页
	 * 
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return 集合对象
	 * @see 开始页:map.get("startPage")
	 * @see 结束页:map.get("pageCount")
	 */
	public static Map<String, Object> calcPageCount(int pageCount, int page, int showPageCount) {
		Map<String, Object> map = new HashMap<String, Object>();
		// 最新开始页码值
		int newStartPage = 1;
		// 最新结束页码值
		int newPageCount = pageCount;
		// 计算左右显示的页码个数
		int prePageCount = showPageCount / 2;
		// 判断右边显示的页码个数
		int modPageCount = showPageCount % 2;
		// 右边多取个页码
		int leftPageCount = prePageCount;
		int rightPageCount = prePageCount;
		if (modPageCount == 0) {
			rightPageCount = rightPageCount - 1;
		}
		// 如果当前页码值大于指定的页码个数
		if (page > prePageCount) {
			// 右边页码个数的最后一个页码
			int endPage = page + rightPageCount;
			// 如果小于总页码个数
			if (endPage < pageCount) {
				// 赋值右边页码个数的最后一个页码
				newPageCount = endPage;
			}
			// 左边页码个数的第一个页码
			newStartPage = page - leftPageCount;
			// 取得当前页面后的右边页码个数(如果rightPageCountCheck=0时,newStartPage=0,所以下面会有判断newStartPage是否小于等于0)
			int rightPageCountCheck = newPageCount - page;
			if (rightPageCountCheck < rightPageCount) {
				// 判断右边页码个数没有达到和左边的页码个数一至
				// 取得右边页码个数相差页码个数
				int rightDiffPageCount = rightPageCount - rightPageCountCheck;
				// 如果未达到,则当前页码前面的页码总数向前移动,使得页码达到11个页码
				newStartPage = newStartPage - rightDiffPageCount;
			}
		} else {
			if (pageCount > showPageCount - 1) {
				// 如果页码个数大于10,则输出最大页码个数11个
				newPageCount = showPageCount;
			}
		}
		if (newStartPage <= 0) {
			// 开始页码从1开始
			newStartPage = 1;
		}
		// 设置返回值
		map.put("startPage", newStartPage);
		map.put("pageCount", newPageCount);
		return map;
	}

	/**
	 * 获取最后分割符前面的字符串
	 * 
	 * @param text
	 * @param split
	 * @return
	 */
	public static String getBeforeTextLastDelimiter(String text, String split) {
		if (text == null)
			return null;
		if ("".equals(text))
			return "";
		int lastIndex = text.lastIndexOf(split);
		if (lastIndex != -1) {
			text = text.substring(0, lastIndex);
		}
		return text;
	}

	/**
	 * 去除小数点后的字符
	 * 
	 * @param text
	 * @param split
	 * @return
	 */
	public static Object getIsNumValue(Object value) {
		if (value == null)
			return null;
		if ("".equals(value))
			return "";
		String stext = value.toString();
		int lastIndex = stext.lastIndexOf(".");
		if (lastIndex == -1) {
			return value;
		}
		String beforeText = getBeforeTextLastDelimiter(stext, ".");
		String afterText = getAfterTextLastDelimiter(stext, ".");
		// System.out.println(beforeText);
		// System.out.println(afterText);
		if (CheckUtil.isPlusNum(beforeText) && CheckUtil.isPlusNum(afterText)) {
			if (BigDecimal.ZERO.compareTo(new BigDecimal(afterText)) == 0) {
				return beforeText;
			} else {
				return value;
			}
		} else {
			return value;
		}
	}

	/**
	 * 获取最后分割符后面的字符串
	 * 
	 * @param text
	 * @param split
	 * @return
	 */
	public static String getAfterTextLastDelimiter(String text, String split) {
		if (text == null)
			return null;
		if ("".equals(text))
			return "";
		int lastIndex = text.lastIndexOf(split);
		if (lastIndex != -1) {
			text = text.substring(lastIndex + 1);
		}
		return text;
	}

	/**
	 * 获取map中的值为map对象
	 * 
	 * @param map
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static synchronized <K, V> Map<K, V> getValueForMap(Map<K, V> map, String key) {
		Map<K, V> valueMap = null;
		Object value = null;
		if (map == null) {
			valueMap = new HashMap<K, V>();
		} else {
			value = map.get(key);
			valueMap = value instanceof Map ? (Map<K, V>) value : new HashMap<K, V>();
		}
		return valueMap;
	}

	/**
	 * 获取map中的值为list.map对象
	 * 
	 * @param map
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static synchronized <K, V> List<Map<K, V>> getValueForListMap(Map<K, V> map, String key) {
		List<Map<K, V>> valueListMap = null;
		Object value = null;
		if (map == null) {
			valueListMap = new ArrayList<Map<K, V>>();
		} else {
			value = map.get(key);
			valueListMap = value instanceof List ? (List<Map<K, V>>) value : new ArrayList<Map<K, V>>();
		}
		return valueListMap;
	}

	/**
	 * 获取map中的值为list对象
	 * 
	 * @param map
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static synchronized <K, V, L> List<L> getValueForList(Map<K, V> map, String key) {
		List<L> valueListMap = null;
		Object value = null;
		if (map == null) {
			valueListMap = new ArrayList<L>();
		} else {
			value = map.get(key);
			valueListMap = value instanceof List ? (List<L>) value : new ArrayList<L>();
		}
		return valueListMap;
	}

	/**
	 * list转set
	 * 
	 * @param map
	 * @param key
	 * @return
	 */
	public static <T> Set<T> listToSet(List<T> P_coll) {
		Set<T> R_coll = new HashSet<T>();
		if (P_coll == null) {
			return R_coll;
		} else {
			for (T V_t : P_coll) {
				R_coll.add(V_t);
			}
		}
		return R_coll;
	}

	/**
	 * set转list
	 * 
	 * @param map
	 * @param key
	 * @return
	 */
	public static <T> List<T> setToList(Set<T> P_coll) {
		List<T> R_coll = new ArrayList<T>();
		if (P_coll == null) {
			return R_coll;
		} else {
			for (T V_t : P_coll) {
				R_coll.add(V_t);
			}
		}
		return R_coll;
	}

	/**
	 * 判断两数组相同
	 * 
	 * @param a1
	 * @param a2
	 * @return
	 */
	public static boolean arrayEquals(Object[] a1, Object[] a2) {
		if (a1 == null) {
			return a2 == null || a2.length == 0;
		}

		if (a2 == null) {
			return a1.length == 0;
		}

		if (a1.length != a2.length) {
			return false;
		}

		for (int i = 0; i < a1.length; i++) {
			if (a1[i] != a2[i]) {
				return false;
			}
		}

		return true;
	}

	/**
	 * 判断两集合是否相同
	 * 
	 * @param list1
	 * @param list2
	 * @return
	 */
	public static boolean collEquals(Collection<Object> list1, Collection<Object> list2) {
		// 个数相同
		boolean ok = true;
		boolean isCheck = false;
		quit: while (list1.size() != 0 && list1.size() == list2.size()) {
			isCheck = true;
			for (Object value : list1) {
				if (list2.contains(value)) {
					list2.remove(value);
					list1.remove(value);
					break;
				} else {
					ok = false;
					break quit;
				}
			}
		}
		// if (isCheck && ok) {
		// System.out.println("集合相同");
		// } else {
		// System.out.println("集合不相同");
		// }
		return isCheck && ok;
	}

	/**
	 * 判断两集合是否相同
	 * 
	 * @param list1
	 * @param list2
	 * @return
	 */
	public static boolean collEqualsStr(Collection<String> list1, Collection<String> list2) {
		List<Object> list1Obj = new ArrayList<Object>();
		List<Object> list2Obj = new ArrayList<Object>();
		for (String v : list1) {
			list1Obj.add(v);
		}
		for (String v : list2) {
			list2Obj.add(v);
		}
		return collEquals(list1Obj, list2Obj);
	}

	/**
	 * 首字母变小写
	 * 
	 * @param text
	 *            字符串
	 * @return 以第一个字母小写其他不变
	 */
	public static String firstLowerCase(String text) {
		return text.substring(0, 1).toLowerCase() + text.substring(1, text.length());
	}

	/**
	 * 首字母变大写
	 * 
	 * @param text
	 * @return
	 */
	public static String firstUpperCase(String text) {
		return text.substring(0, 1).toUpperCase() + text.substring(1, text.length());
	}

	/**
	 * 以分割符split首字母变大写(默认第一个字符不改变大写)
	 * 
	 * @param text
	 *            校验字符串
	 * @param split
	 *            分割符
	 * @return 转换后的结果
	 */
	public static String upperCaseSplit(String text, String split) {
		return upperCaseSplit(text, split, false);
	}

	/**
	 * 以分割符split首字母变大写
	 * 
	 * @param text
	 *            校验字符串
	 * @param split
	 *            分割符
	 * @param first
	 *            是否首字母大写
	 * @return 转换后的结果
	 */
	public static String upperCaseSplit(String text, String split, boolean first) {
		String[] texts = split(text, split);
		String newText = "";
		for (int i = 0; i < texts.length; i++) {
			String str = texts[i];
			if (CheckUtil.isNull(str)) {
				continue;
			}
			if (i == 0) {
				if (first) {
					newText += firstUpperCase(str);
				} else {
					newText += str;
				}
			} else {
				newText += firstUpperCase(str);
			}
		}
		return newText;
	}

	/**
	 * 转换数据库字段为java属性
	 * 
	 * @param text
	 *            数据库字段名
	 * @author 张军
	 * @date 2015-11-03 21:59:00
	 * @modifiyNote
	 * @version 1.0
	 * @return
	 */
	public static String convertDbToJavaField(String text) {
		return JavaUtil.upperCaseSplit(JavaUtil.toLowerCase(text), "_");
	}

	/**
	 * 改变第一行bug BufferedReader.readLine()读取第一行会出现bug,首行第一个字符会是一个空字符  line = br.readLine(); line = readFirstLine(line); 文件保存为UTF-8格式,会出现此问题(例如:文件内容第一行以#号开头) stream/a.txt不正常,b.txt正常
	 * 
	 * @param line
	 * @return
	 * @author zhangjun
	 */
	public static String readFirstLine(String line) {
		if (line == null)
			return null;
		line = line.trim();
		if ("".equals(line)) {
			return line;
		}
		char s = line.charAt(0);
		int hc = String.valueOf(s).hashCode();
		if (hc == 65279) {
			if (line.length() > 1) {
				line = line.substring(1);
			} else {
				line = "";
			}
		}
		return line;
	}

	/**
	 * 随机数
	 * 
	 * @author zhangjun
	 * 
	 */
	public static class RandomUtil {
		private static Random RD = null;
		static {
			RD = new Random();
		}

		/**
		 * 获取[s-e]之间的随机数
		 * 
		 * @param s
		 *            开始数字
		 * @param e
		 *            结束数字
		 * @return 随机数
		 */
		public static int getInt(int s, int e) {
			return RD.nextInt(e - s + 1) + s;
		}
	}

	/**
	 * 获取手机号去掉+86
	 *
	 * @param P_mobile
	 *            手机号
	 * @return
	 */
	public static String getMobile(String P_mobile) {
		if (CheckUtil.isNull(P_mobile)) {
			return "";
		}
		if (P_mobile.startsWith("+86")) {
			// 去除
			P_mobile = P_mobile.substring(3);
		}
		return P_mobile;
	}

	/**
	 * 字符串转set
	 *
	 * @param value
	 *            字符串
	 * @return
	 */
	public static Set<String> strToSet(String value) {
		return strToSet(value, ",");
	}

	/**
	 * 字符串转list
	 *
	 * @param value
	 *            字符串
	 * @return
	 */
	public static List<String> strToList(String value) {
		return strToList(value, ",");
	}

	/**
	 * 字符串转set
	 *
	 * @param value
	 *            字符串
	 * @param split
	 *            分割符
	 * @return
	 */
	public static Set<String> strToSet(String value, String split) {
		Set<String> V_toIds = new HashSet<>();
		String[] R_sysIdsAry = JavaUtil.split(value, split);
		for (String VF_value : R_sysIdsAry) {
			V_toIds.add(VF_value);
		}
		return V_toIds;
	}

	/**
	 * 字符串转list
	 *
	 * @param value
	 *            字符串
	 * @param split
	 *            分割符
	 * @return
	 */
	public static List<String> strToList(String value, String split) {
		List<String> V_toIds = new ArrayList<>();
		String[] R_sysIdsAry = JavaUtil.split(value, split);
		for (String VF_value : R_sysIdsAry) {
			V_toIds.add(VF_value);
		}
		return V_toIds;
	}
}
/**
 * @Description  TestJavaUtil.java
 * @author 张军
 * @date 2022年3月6日 上午10:48:53
 * @version V1.0
 */
package test.java;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.Test;

import zj.check.util.CheckUtil;
import zj.java.util.JavaUtil;

/**
 * @author 张军
 * @date 2022年3月6日 上午10:48:53
 * @version V1.0
 */
public class TestJavaUtil {
	@Test
	public void 分割email地址转换成一行() {
		String 前台传的email值 = "";
		for (int a = 1; a <= 5; a++) {
			if (CheckUtil.isNotNull(前台传的email值)) {
				前台传的email值 += "\r\n";
			}
			前台传的email值 += "zhangjun" + a + "@126.com";
		}
		System.out.println("前台传的email值:\n" + 前台传的email值);
		String 分割后结果 = JavaUtil.emailSplitToOneline(前台传的email值);
		System.out.println("分割后结果:\n" + 分割后结果);
	}

	@Test
	public void 判断系统() {
		System.out.println("是否是windows:" + JavaUtil.isWindows());
		System.out.println("是否是mac系统:" + JavaUtil.isMac());
	}

	@Test
	public void 中文数字转数字() {
		System.out.println("中文数字转数字:" + JavaUtil.getIntegerByStr("六万七千三百八十二"));
		System.out.println("中文数字转数字:" + JavaUtil.getIntegerByStr("五千零一"));
	}

	@Test
	public void 数字转大写() {
		System.out.println("数字转大写:" + JavaUtil.numToCnChar("1234567890"));
	}

	@Test
	public void 数字转大写日期() {
		System.out.println("4位数字年:" + JavaUtil.numToCnCharDate(2022));
		System.out.println("2位数字月或日:" + JavaUtil.numToCnCharDate(12));
		System.out.println("1位数字月或日:" + JavaUtil.numToCnCharDate(9));
	}

	@Test
	public void 数值转换为中文字符串() {
		System.out.println("数值转换为中文字符串:" + JavaUtil.numToCn(20221231));
		System.out.println("第2个参数是否口语化。例如12转换为'十二'而不是'一十二'。:" + JavaUtil.numToCnCharDate(12));
	}

	@Test
	public void 获取集合差异() {
		List<String> l1 = new ArrayList<>();
		l1.add("a");
		l1.add("b");
		l1.add("c");
		l1.add("d");
		l1.add("e");
		List<String> l2 = new ArrayList<>();
		l2.add("a1");
		l2.add("b");
		l2.add("c1");
		l2.add("d");
		l2.add("e1");
		System.out.println("获取集合差异:" + JavaUtil.diffColl(l1, l2));
	}

	@Test
	public void 数字格式化() {
		System.out.println("数字格式化:" + JavaUtil.covertToNumSplit(1234567890));
	}

	@Test
	public void 转为大数字() {
		System.out.println("转为大数字:" + JavaUtil.covertBigDecimal(1234567890));
		System.out.println("转为大数字:" + JavaUtil.covertBigDecimal("1234567890123456789").setScale(5, BigDecimal.ROUND_HALF_UP));
	}

	@Test
	public void 获取in的字符串() {
		List<String> l2 = new ArrayList<>();
		l2.add("a1");
		l2.add("b");
		l2.add("c1");
		l2.add("d");
		l2.add("e1");
		System.out.println("获取in的字符串: in(" + JavaUtil.sqlInStr(l2) + ")");
	}

	@Test
	public void 转换文件大小() {
		System.out.println("转换文件大小为B、KB、MB、GB:" + JavaUtil.convertFileSize(123456));
		System.out.println("转换文件大小为B、KB、MB、GB:" + JavaUtil.convertFileSize(1234567890));
	}

	@Test
	public void 深度拷贝list数据() {
		List<String> 源集合 = new ArrayList<>();
		源集合.add("a");
		源集合.add("b");
		源集合.add("c");
		源集合.add("d");
		源集合.add("e");
		List<String> 目标集合 = JavaUtil.deepCopy(源集合);
		源集合.remove(0);
		源集合.remove(1);
		System.out.println("源集合:" + 源集合);
		System.out.println("移除src里的元素,dest元素不会发生变化");
		System.out.println("目标集合:" + 目标集合);
	}

	@Test
	public void 合并多个数组() {
		String[] 数组1 = new String[] { "a", "b", "c" };
		String[] 数组2 = new String[] { "d", "e", "f" };
		String[] 数组3 = new String[] { "11", "22", "33" };
		System.out.println("数组1:" + Arrays.toString(数组1));
		System.out.println("数组2:" + Arrays.toString(数组2));
		System.out.println("数组3...n:" + Arrays.toString(数组3));
		System.out.println("合并N个数组:" + Arrays.toString(JavaUtil.concatArrayAll(数组1, 数组2, 数组3)));
	}

	@Test
	public void 按实际字符分割字符串() {
		String 字符串 = "a.b.c.d.e";
		System.out.println("按实际字符分割字符串:" + Arrays.toString(JavaUtil.split(字符串, ".")));
	}

	@Test
	public void LIST转数组() {
		List<String> 源集合 = new ArrayList<>();
		源集合.add("a");
		源集合.add("b");
		源集合.add("c");
		源集合.add("d");
		源集合.add("e");
		System.out.println("LIST转数组:" + Arrays.toString(JavaUtil.listToArray(源集合, String.class)));
	}

	@Test
	public void 获取最大长度文字() {
		System.out.println("获取最大长度文字:" + JavaUtil.getMaxText("获取最大长度文字", 3));
	}

	@Test
	public void 去除数组中为null或空的值() {
		String[] 数组1 = new String[] { "a", "b", "c", "", "", null, "\n", "666666666" };
		System.out.println("去除数组前的值:" + Arrays.toString(数组1));
		System.out.println("去除数组中为null或空的值:" + Arrays.toString(JavaUtil.aryTrimValue(数组1)));
	}

	@Test
	public void 提取字符串中的整数字() {
		System.out.println("提取字符串:" + "我是123中456国7890结束");
		System.out.println("提取字符串中的整数字:" + JavaUtil.conversionStringToNum("我是123中456国7890结束"));
	}

	@Test
	public void 提取字符串中的整数字带小数或正负数() {
		System.out.println("提取字符串:" + "我是-123中456国7.890结束");
		System.out.println("提取字符串中的整数字带小数或正负数:" + JavaUtil.conversionStringToNumber("我是-123中456国7.890结束"));
	}

	@Test
	public void 固定集合元素() {
		int count = 10;
		List<String> 原集合值 = new ArrayList<String>();
		for (int i = 0; i < count; i++) {
			原集合值.add("值:" + i);
		}
		System.out.println("原集合值:" + 原集合值);
		List<List<String>> 固定批量值 = JavaUtil.getBatchList(原集合值, 3);
		System.out.println("固定集合元素,每个集合3个元素:" + 固定批量值);
	}

	@Test
	public void 固定批量集合() {
		int count = 10;
		List<String> 原集合值 = new ArrayList<String>();
		for (int i = 0; i < count; i++) {
			原集合值.add("值:" + i);
		}
		System.out.println("原集合值:" + 原集合值);
		List<List<String>> 固定批量值 = JavaUtil.getFixedBatchList(原集合值, 3);
		System.out.println("固定批量集合,3个批次元素:" + 固定批量值);
	}

	@Test
	public void 根据页码条数计算多少页() {
		System.out.println("总条数:" + 10);
		System.out.println("每页显示条数:" + 3);
		System.out.println("根据页码条数计算多少页:" + JavaUtil.calcPageCount(10, 3));
	}

	@Test
	public void 获取最后分割符前面的字符串() {
		String 字符串 = "获取最后分割符#前面的字符串";
		System.out.println("字符串:" + 字符串);
		System.out.println("获取最后分割符#前面的字符串:" + JavaUtil.getBeforeTextLastDelimiter(字符串, "#"));
	}

	@Test
	public void 获取最后分割符后面的字符串() {
		String 字符串 = "获取最后分割符#前面的字符串";
		System.out.println("字符串:" + 字符串);
		System.out.println("获取最后分割符#前面的字符串:" + JavaUtil.getAfterTextLastDelimiter(字符串, "#"));
	}

	@Test
	public void 去除小数点后的字符() {
		System.out.println("去除前字符:123.12345000");
		System.out.println("去除小数点后为0的字符:" + JavaUtil.getIsNumValue(123.12345000));
		System.out.println("去除前字符:12345678.00000");
		System.out.println("去除小数点后为0的字符:" + JavaUtil.getIsNumValue("12345678.00000"));
	}

	@Test
	public void 获取map中的值为map对象() {
		Map<String, Map<String, Object>> map = new HashMap<>();
		Map<String, Object> value = new HashMap<>();
		value.put("test", "我是值a");
		map.put("a", value);
		value = new HashMap<>();
		value.put("test", "我是值b");
		map.put("b", value);
		value = new HashMap<>();
		value.put("test", "我是值c");
		map.put("c", value);
		System.out.println("map:" + map);
		System.out.println("获取map中key为b的值为map对象:" + JavaUtil.getValueForMap(map, "b"));
		System.out.println("获取map中key为d的值为map对象:" + JavaUtil.getValueForMap(map, "d"));
	}

	@Test
	public void 获取map中的值为list_map对象() {
		Map<String, List<Map<String, Object>>> map = new HashMap<>();
		List<Map<String, Object>> values = new ArrayList<>();
		
		Map<String, Object> value = new HashMap<>();
		values.add(value);
		value.put("test", "我是值a");
		map.put("a", values);

		value = new HashMap<>();
		values.add(value);
		value.put("test", "我是值b");
		map.put("b", values);

		value = new HashMap<>();
		values.add(value);
		value.put("test", "我是值c");
		map.put("c", values);

		System.out.println("map:" + map);
		System.out.println("获取map中的值为list.map对象:" + JavaUtil.getValueForListMap(map, "b"));
		System.out.println("获取map中的值为list.map对象:" + JavaUtil.getValueForListMap(map, "d"));
	}
}
map:{b=[{test=我是值a}, {test=我是值b}, {test=我是值c}], c=[{test=我是值a}, {test=我是值b}, {test=我是值c}], a=[{test=我是值a}, {test=我是值b}, {test=我是值c}]}
获取map中的值为list.map对象:[{test=我是值a}, {test=我是值b}, {test=我是值c}]
获取map中的值为list.map对象:[]
map:{b={test=我是值b}, c={test=我是值c}, a={test=我是值a}}
获取map中key为b的值为map对象:{test=我是值b}
获取map中key为d的值为map对象:{}
原集合值:[值:0, 值:1, 值:2, 值:3, 值:4, 值:5, 值:6, 值:7, 值:8, 值:9]
固定批量集合,3个批次元素:[[值:0, 值:1, 值:2, 值:3], [值:4, 值:5, 值:6, 值:7], [值:8, 值:9]]
获取集合差异:[e1, e, c1, c, a, a1]
原集合值:[值:0, 值:1, 值:2, 值:3, 值:4, 值:5, 值:6, 值:7, 值:8, 值:9]
固定集合元素,每个集合3个元素:[[值:0, 值:1, 值:2], [值:3, 值:4, 值:5], [值:6, 值:7, 值:8], [值:9]]
数字格式化:1,234,567,890
数字转大写:一二三四五六七八九零
数组1:[a, b, c]
数组2:[d, e, f]
数组3...n:[11, 22, 33]
合并N个数组:[a, b, c, d, e, f, 11, 22, 33]
提取字符串:我是123中456国7890结束
提取字符串中的整数字:1234567890
数值转换为中文字符串:二千零二十二万一千二百三十一
第2个参数是否口语化。例如12转换为'十二'而不是'一十二'。:十二
4位数字年:二零二二
2位数字月或日:十二
1位数字月或日:九
提取字符串:我是-123中456国7.890结束
提取字符串中的整数字带小数或正负数:-1234567.890
转为大数字:1234567890
转为大数字:1234567890123456789.00000
是否是windows:true
是否是mac系统:false
LIST转数组:[a, b, c, d, e]
前台传的email值:
zhangjun1@126.com
zhangjun2@126.com
zhangjun3@126.com
zhangjun4@126.com
zhangjun5@126.com
分割后结果:
zhangjun1@126.com;zhangjun2@126.com;zhangjun3@126.com;zhangjun4@126.com;zhangjun5@126.com
字符串:获取最后分割符#前面的字符串
获取最后分割符#前面的字符串:前面的字符串
字符串:获取最后分割符#前面的字符串
获取最后分割符#前面的字符串:获取最后分割符
获取in的字符串: in('a1','b','c1','d','e1')
获取最大长度文字:获取最...
去除前字符:123.12345000
去除小数点后为0的字符:123.12345
去除前字符:12345678.00000
去除小数点后为0的字符:12345678
去除数组前的值:[a, b, c, , , null, 
, 666666666]
去除数组中为null或空的值:[a, b, c, 666666666]
按实际字符分割字符串:[a, b, c, d, e]
转换文件大小为B、KB、MB、GB:120.56KB
转换文件大小为B、KB、MB、GB:1.15GB
中文数字转数字:67382
中文数字转数字:5001
总条数:10
每页显示条数:3
根据页码条数计算多少页:4
源集合:[b, d, e]
移除src里的元素,dest元素不会发生变化
目标集合:[a, b, c, d, e]

更多文章、技术交流、商务合作、联系博主

微信扫码或搜索:z360901061

微信扫一扫加我为好友

QQ号联系: 360901061

您的支持是博主写作最大的动力,如果您喜欢我的文章,感觉我的文章对您有帮助,请用微信扫描下面二维码支持博主2元、5元、10元、20元等您想捐的金额吧,狠狠点击下面给点支持吧,站长非常感激您!手机微信长按不能支付解决办法:请将微信支付二维码保存到相册,切换到微信,然后点击微信右上角扫一扫功能,选择支付二维码完成支付。

【本文对您有帮助就好】

您的支持是博主写作最大的动力,如果您喜欢我的文章,感觉我的文章对您有帮助,请用微信扫描上面二维码支持博主2元、5元、10元、自定义金额等您想捐的金额吧,站长会非常 感谢您的哦!!!

发表我的评论
最新评论 总共0条评论