Java 工具函数

//要求j2se 1.4
package com.yss.framework.api.util;

import java.io.IOException;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.regex.Pattern;

import com.yss.framework.api.common.co.BEN_INFO;
import com.yss.framework.api.common.co.BasePojo;
import com.yss.framework.api.exception.YssException;
import com.yss.framework.api.logger.LogManager;

/**
 * <p>
 * Title:公用函数，请勿加入数据库访问类函数！
 * </p>
 * <p>
 * Description: 这个类包含了一些常用的函数，如日期的分析处理，数值的判断等等 <br>
 * 一些VB中常用java中使用不便的函数
 * </p>
 * <p>
 * Copyright: Copyright (c) 2003
 * </p>
 * <p>
 * Company: Ysstech
 * </p>
 * 
 * @author alex
 * @version 1.0
 */
public class YssFun 
{
	/**
	 * default Constructor
	 */
	public YssFun() 
	{
	}

	// 时间日期类函数****************************************************************
	// 这些函数都是基于java.util.date，java.sql.date类型的参数也可填入处理

	/**
	 * 两种日期类型转换 java.sql.date本身就是java.util.date不用转换
	 * java.util.date到java.sql.date的转换用这个函数实现
	 * @param dDate java.util.Date
	 * @return  java.sql.Date
	 */
	public static java.sql.Date toSqlDate(Date dDate) 
	{
		return new java.sql.Date(dDate.getTime());
	}

	/**
	 * 将日期字符串转换为java.sql.Date
	 * @param strDate 日期字符串
	 * @return java.sql.Date
	 * @throws YssException
	 */
	public static java.sql.Date toSqlDate(String strDate) throws YssException 
	{
		Date dDate = toDate(strDate); //
		return new java.sql.Date(dDate.getTime());
	}

	/**
	 * 日期格式化，类似vb的format
	 * 
	 * @param dDate
	 *            Date
	 * @param format
	 *            String：日期格式
	 * @return String：返回格式化好的日期字符串
	 */
	public static String formatDate(Date dDate, String format)
	{
		return (new SimpleDateFormat(format)).format(dDate);
	}

	/**
	 * 日期格式化，采用日期字符串做源日期参数
	 * 
	 * @param sDate
	 *            String
	 * @param format
	 *            String
	 * @throws YssException
	 * @return String
	 */
	public static String formatDate(String sDate, String format)
			throws YssException 
	{
		String dataFormatStr = "";
		
		if(sDate != null && !"".equals(sDate)){
			if (format.equalsIgnoreCase(YssCons.YSS_DATEFORMAT)) {
				sDate = YssFun.left(sDate, 10);
			}
			
			dataFormatStr = formatDate(toDate(sDate), format);
		}
		 // end if
		
		return dataFormatStr;
	}

	/**
	 * 格式化日期显示
	 * @param sDate
	 * @return 格式化后的日期字符串
	 * @throws YssException
	 */
	public static String formatDate(String sDate) throws YssException 
	{
		return formatDate(sDate, YssCons.YSS_DATEFORMAT);
	}

	/**
	 * 日期格式化，用标准格式yyyy-MM-dd
	 * @param dDate
	 * @return 格式化后的日期字符串
	 */
	public static String formatDate(Date dDate) 
	{
		if (dDate == null) 
			return "";
		return (new SimpleDateFormat(YssCons.YSS_DATEFORMAT)).format(dDate);
	}

	/**
	 * 时间格式化，用标准格式yyyyMMdd hh:mm:ss
	 * @param dDate
	 * @return 格式化后的日期字符串
	 */
	public static String formatDatetime(Date dDate) 
	{
		return (new SimpleDateFormat(YssCons.YSS_DATETIMEFORMAT)).format(dDate);
	}

	/**
	 * 字符串to日期时间 注意要指定日期格式，不像vb可以自动识别
	 * @param sDate
	 * @param format
	 * @return 解析后得到的java.util.Date
	 * @throws YssException
	 */
	public static Date parseDate(String sDate, String format)
			throws YssException 
	{
		GregorianCalendar cl = new GregorianCalendar(); //
		final String derr = "解析日期出错！"; //
		int year = 0; //

		try {
			cl.setTime((new SimpleDateFormat(format)).parse(sDate));
			year = cl.get(Calendar.YEAR);
			// 年份要控制一下
			if (year < 1000 || year > 9999) {
				throw new YssException(derr + "\n\t年份必须在1000－9999之间");
			} // end if

			return cl.getTime();
		} catch (ParseException pe) {
			throw new YssException(derr, pe);
		}
	}

	/**
	 * 日期解析，用标准格式yyyy-MM-dd
	 * @param sDate
	 * @return 解析后得到的日期
	 * @throws YssException
	 */
	public static Date parseDate(String sDate) throws YssException 
	{
		return parseDate(sDate, YssCons.YSS_DATEFORMAT);
	}

	/**
	 * 是否可以转换成日期，仅解析用/-.间隔的日期 dDate用于返回日期，改写dDate中已经存在的日期
	 * @param sDate
	 * @param dDate
	 * @return 是否可以转换
	 */
	public static boolean isDate(String sDate, Date dDate) 
	{
		long ltmp = 0; //
		try {
			ltmp = toDate(sDate).getTime();

			if (null != dDate) {
				dDate.setTime(ltmp);
			} // end if
			
			return true;
		} catch (YssException ye) {
			return false;
		}
	}

	/**
	 * 判断是否为日期
	 * @param sDate
	 * @return 是否为日期
	 */
	public static final boolean isDate(String sDate) 
	{
		return isDate(sDate, null);
	}

	/**
	 * 根据format格式生成日期<br>
	 * 例如format="MMDDyyyy"：表示前两位为月份、中间两位为日期，后四位为年份
	 * @param sDate 日期字符串，可以为yyyyMMDD或MMDDyyyy或yyyy-MM-dd
	 * @param format 格式化字符串
	 * @return 返回日期
	 * @throws YssException
	 */
	public static Date toDate(String sDate,String format) throws YssException{
		return parseDate(sDate,format);
	}
	/**
	 * 类似vb的CDate函数，自动分析sDate，如格式正常，返回日期，否则报错。<br>
	 * 注意这里只能处理单纯日期，不处理时间，年份正常范围在0-99和1000－9999 仅解析用/-.间隔的日期<br>
	 * 修改采用"."为分隔符的日期字符串的BUG，因为"."作为正则表达式的特殊字符，故做分隔符时用"\."处理 by leeyu 20111124<br>
	 * @param sDate
	 * @return 返回的日期
	 * @throws YssException
	 */
	public static Date toDate(String sDate) throws YssException 
	{
		int jj = 0; //
		char ss =0;
		char cc = 0;
		String[] sss = { "-", "/", "\\." };
		String[] result = null; //
		int kk = 0; //
		int mm = 0; //
		final String emsg = "非法日期格式！"; //

		GregorianCalendar cl = null; //

		if(sDate == null ){
			throw new YssException("参数为空，转换失败！");
		}
		
		// 将日期后面的时间去掉，这里只转日期部分byleeyu20120717
		if(sDate.length()>10){
			sDate = sDate.substring(0,10);
		}
		
		// 检查分隔符
		for (jj = 0; jj < sss.length; jj++) {
			if (sDate.split(sss[jj]).length > 1) {
				break;
			} // end if
		} // end for
		
		if (jj >= sss.length) {
			throw new YssException(emsg);
		} // end if

		ss = sss[jj].length()== 2 ? sss[jj].charAt(1) : sss[jj].charAt(0);
		// 检查数字有效性即除了数字和分隔符，不应该再包括其它字符
		for (int i = 0; i < sDate.length(); i++) {
			cc = sDate.charAt(i);
			if (cc != ss && (cc < '0' || cc > '9')) {
				throw new YssException(emsg);
			} // end if
		} // end for

		// 劈开，获取3个数字
		result = sDate.split(sss[jj], -1); // 检查全部，包括空的元素，用0会忽略空
		if (3 != result.length) {
			throw new YssException(emsg);
		} // end if
		
		jj = Integer.parseInt(result[0]);
		kk = Integer.parseInt(result[1]);
		mm = Integer.parseInt(result[2]);

		// 判断是否符合一种日期格式
		// 1、y/M/d格式
		if (isValidDate(jj, kk, mm)) {
			cl = new GregorianCalendar(jj < 30 ? jj + 2000
					: (jj <= 99 ? jj + 1900 : jj), kk - 1, mm);
		} else {
			if (mm < 30) {
				mm += 2000;
			} else if (mm <= 99) {
				mm += 1900;
				// 2、M/d/y格式
			} // end if
			
			if (isValidDate(mm, jj, kk)) {
				cl = new GregorianCalendar(mm, jj - 1, kk);
				// 3、d/M/y格式
			} else if (isValidDate(mm, kk, jj)) {
				cl = new GregorianCalendar(mm, kk - 1, jj);
			} else {
				throw new YssException(emsg);
			} // end if
		} // end if
		
		return cl.getTime();
	}
	
	/**
	 * 根据年、月、日 生成一个日期 <br>
	 * 这里不考虑这三个参数是否合法，如果需要请使用{@link #YssFun.isValidDate(int year, int month, int day)}验证
	 * @param year 年份
	 * @param month 月份，范围:1~12
	 * @param day 日期 ，范围:1~31
	 * @return 普通的日期
	 */
	public static java.util.Date toDate(int year,int month,int day){
		GregorianCalendar cl = new GregorianCalendar(year, month-1, day);
		return cl.getTime();
	}

	/**
	 * 判断年月日是否在正常范围 年份正常范围在0-99和1000－9999
	 */
	public static boolean isValidDate(int year, int month, int day) 
	{
		GregorianCalendar cl;

		if (year < 0 || (year > 99 && (year < 1000 || year > 9999))) {
			return false;
		} // end if
		
		if (year < 30) {
			year += 2000;
		} else if (year <= 99) {
			year += 1900;
		} // end if
		
		if (month < 1 || month > 12) {
			return false;
		} // end if

		cl = new GregorianCalendar(year, month - 1, 1); // 参数月份从0开始所以减一
		if (day < cl.getActualMinimum(Calendar.DAY_OF_MONTH)
				|| day > cl.getActualMaximum(Calendar.DAY_OF_MONTH)) {
			return false;
		} // end if

		return true;
	}

	/**
	 * 得到年份(月份getMonth，日getDay，星期getWeekDay) 包装了GregorianCalendar类的get方法
	 * Calendar类中定义了月份，星期几的常数。 <br>
	 * <big><b>注意月份常数0开始，一般不要使用</b></big>
	 */
	public static int getYear(Date dDate) 
	{
		return getDateItems(dDate, Calendar.YEAR);
	}

	// 得到月份
	public static int getMonth(Date dDate) 
	{
		return getDateItems(dDate, Calendar.MONTH) + 1;
	}

	// 日
	public static int getDay(Date dDate) 
	{
		return getDateItems(dDate, Calendar.DAY_OF_MONTH);
	}

	// 星期几
	public static int getWeekDay(Date dDate) 
	{
		return getDateItems(dDate, Calendar.DAY_OF_WEEK);
	}

	/**
	 * 返回日期中的任何元素
	 * 
	 * @param field
	 *            ：Calendar类中的常数，如YEAR/MONTH/DAY_OF_MONTH... <br>
	 *            <b><big>注意返回的month一月份是从0开始的！</big></b>
	 */
	public static final int getDateItems(Date dDate, int field) 
	{
		GregorianCalendar cl = new GregorianCalendar();
		cl.setTime(dDate);
		return cl.get(field);
	}

	/**
	 * 加减day，月份是addMonth，年份addYear
	 */
	public static final Date addDay(Date dDate, int days) {
		return addDate(dDate, days, Calendar.DAY_OF_MONTH);
	}

	public static final Date addMonth(Date dDate, int months) {
		return addDate(dDate, months, Calendar.MONTH);
	}

	public static final Date addYear(Date dDate, int years) {
		return addDate(dDate, years, Calendar.YEAR);
	}

	/**
	 * 加减日期 field指定是年、月、日，amount是数量
	 */
	public static Date addDate(Date dDate, int amount, int field) {
		GregorianCalendar cl = new GregorianCalendar();
		cl.setTime(dDate);
		cl.add(field, amount);

		return cl.getTime();
	}

	/**
	 * 返回两个日期相差date2-date1的天数
	 * 
	 * @param dDate1
	 *            ：被减日期
	 * @param dDate2
	 *            ：日期
	 */
	public static int dateDiff(java.util.Date dDate1, java.util.Date dDate2) {
		int year = 0;
		int month = 0;
		int day = 0;
		// 算法说明：这里考虑到了时分秒的差异可能造成的差一天，只设置年月日相减算出差异
		// 失败算法：毫秒数相减除一天毫秒；毫秒数先除再减；毫秒数弥补时区差后先除再减
		// 失败算法：设置calendar的时分秒为0后相减（有时设置不灵）
		GregorianCalendar cl1 = new GregorianCalendar();
		GregorianCalendar cl2 = null;

		cl1.setTime(dDate2);
		// cl1.set(Calendar.MONTH,YssFun.getMonth(dDa);
		year = cl1.get(Calendar.YEAR);
		month = cl1.get(Calendar.MONTH);
		day = cl1.get(Calendar.DAY_OF_MONTH);

		cl2 = new GregorianCalendar(year, month, day);

		cl1.setTime(dDate1);
		year = cl1.get(Calendar.YEAR);
		month = cl1.get(Calendar.MONTH);
		day = cl1.get(Calendar.DAY_OF_MONTH);
		cl1.clear();
		cl1.set(year, month, day);

		return (int) ((cl2.getTimeInMillis() - cl1.getTimeInMillis()) / (1000 * 3600 * 24));
	}

	/**
	 * date2-当前日期的差
	 */
	public static int dateDiff(java.util.Date dDate2) {
		return dateDiff(new java.util.Date(), dDate2);
	}

	/**
	 * 通过只算年份和月份，获取月份差，不计四舍五入
	 * 
	 * @param dDate1
	 *            Date：起始月
	 * @param dDate2
	 *            Date：终止月
	 * @return int：dDate2-dDate1的月份差
	 */
	public static int monthDiff(java.util.Date dDate1, java.util.Date dDate2) {
		int year, month;
		GregorianCalendar cld = new GregorianCalendar();

		cld.setTime(dDate2);
		year = cld.get(Calendar.YEAR);
		month = cld.get(Calendar.MONTH);

		cld.setTime(dDate1);
		year -= cld.get(Calendar.YEAR);
		month -= cld.get(Calendar.MONTH);

		return year * 12 + month;
	}

	/**
	 * date2-当前日期，月份差
	 */
	public static int monthDiff(java.util.Date dDate2) {
		return monthDiff(new java.util.Date(), dDate2);
	}

	/**
	 * 判断闰年 return new GregorianCalendar().isLeapYear(year);
	 */
	public static boolean isLeapYear(int year) {
		return new GregorianCalendar().isLeapYear(year);
	}

	public static boolean isLeapYear(Date dDate) {
		GregorianCalendar cl = new GregorianCalendar();
		cl.setTime(dDate);
		return cl.isLeapYear(cl.get(Calendar.YEAR));
	}

	/**
	 * 获取指定年份范围内的闰年数
	 * 
	 * @param startYear
	 *            ：起始年（包含）
	 * @param endYear
	 *            ：结束年（包含）
	 */
	public static int getLeapYears(int startYear, int endYear) {
		int count = 0;
		GregorianCalendar cl = new GregorianCalendar();
		for (int i = startYear; i <= endYear; i++) {
			if (cl.isLeapYear(i)) {
				count++;
			}
		}
		return count;
	}

	/**
	 * 获取指定日期范围内的闰年数
	 * 
	 * @param startDate
	 *            ：起始日期（包含）
	 * @param endDate
	 *            ：结束日期（包含）
	 */
	public static int getLeapYears(Date startDate, Date endDate) {
		int syear, eyear;
		syear = getYear(startDate);
		eyear = getYear(endDate);
		// ------ modify by wangzuochun 2010.04.17 MS00980
		// 程序在获取计息天数时因闰年判断有误导致债券业务数据有错 QDII4.1赢时胜上海2010年04月14日01_B
		if (formatDate(startDate, "MMdd").compareTo("0229") > 0) {
			syear++;
		} // end if
		
		if (formatDate(endDate, "MMdd").compareTo("0229") < 0) {
			eyear--;
		} // end if
		
		// ---------------------- MS00980 ---------------------------//
		return getLeapYears(syear, eyear);
	}

	/**
	 * 月末日28/29/30/31？ 使用GregorianCalendar.getActualMaximum
	 */
	public static int endOfMonth(int year, int month) {
		return new GregorianCalendar(year, month - 1, 1)
				.getActualMaximum(Calendar.DAY_OF_MONTH);
	}

	public static int endOfMonth(Date dDate) {
		GregorianCalendar cl = new GregorianCalendar();
		cl.setTime(dDate);
		return cl.getActualMaximum(Calendar.DAY_OF_MONTH);
	}

	// 数字类函数********************************************************************
	// (因为金额小数只有两位，所以double可以表示足够大的数据)

	/**
	 * 判断是否数值 Decimal
	 */
	public static boolean isNumeric(String sNum) {
		try {
			if (sNum == null || sNum.trim().length() == 0) {
				return false;
			}
			toNumber(sNum);
			return true;

		} catch (YssException ye) {
			LogManager.getLogger(YssFun.class).log("判断字符串是否数值出错！", ye);
			return false;
		}
	}

	/**
	 * 自动分析sNum格式，解析成double类型返回 支持千分符，科学计数，百分数...前后空格，前导的+号和0 遇其它非法格式报错
	 */
	public static double toNumber(String sNum) throws YssException {
		int i = 0;
		DecimalFormat df = new DecimalFormat(sNum.indexOf("%") > 0 ? "#,###.#%"
				: "#,###.#E0");

		try {
			sNum = trim(sNum);
			if (sNum.length() > 1) {
				if (sNum.charAt(0) == '0') { // 去前导连续0，注意只有一个0的情况
					if (sNum.charAt(1) != '.') {
						for (i = 0; i < sNum.length() - 1; i++) {
							if (sNum.charAt(i) != '0') {
								break;
							}
						}
					}
				} else if (sNum.charAt(0) == '+') {
					i = 1;
				}
			}
			if (sNum.equals("")) {
				sNum = "0";
			}
			return df.parse((0 == i) ? sNum : sNum.substring(i)).doubleValue();
		} catch (Exception pe) {
			throw new YssException("非法数值格式！", pe);
		}
	}
	
	public static BigDecimal toDecimal(String sNum) throws YssException{
		int i = 0;
		DecimalFormat df = new DecimalFormat(sNum.indexOf("%") > 0 ? "#,###.#%"
				: "#,###.#E0");
		
		//Orlando 2012-8-21 需要明确指出格式化为bigDecimal，默认是FALSE
		df.setParseBigDecimal(true);
		
		BigDecimal decimal = null;
		try {
			sNum = trim(sNum);
			if (sNum.length() > 1) {
				if (sNum.charAt(0) == '0') { // 去前导连续0，注意只有一个0的情况
					if (sNum.charAt(1) != '.') {
						for (i = 0; i < sNum.length() - 1; i++) {
							if (sNum.charAt(i) != '0') {
								break;
							}
						}
					}
				} else if (sNum.charAt(0) == '+') {
					i = 1;
				}
			}
			if (sNum.equals("")) {
				sNum = "0";
			}
			
			decimal = new BigDecimal(df.parse((0 == i) ? sNum : sNum.substring(i)).toString());
		} catch (Exception pe) {
			throw new YssException("非法数值格式！", pe);
		}
		return decimal;
	}

	/**
	 * 把字符串变双精度，格式不对返回0，不报错
	 * 
	 * @param sNum
	 *            String
	 * @return int
	 */
	public static double toDouble(String sNum) {
		try {
			if (sNum.equalsIgnoreCase("")) {
				return 0.0;
			}
			return toNumber(sNum);
		} catch (Exception e) {
			LogManager.getLogger(YssFun.class).log("转换字符串到 Double 出错！", e);
			return 0.0;
		}
	}

	/**
	 * 把字符串变整数，格式不对返回0，不报错
	 * 
	 * @param sNum
	 *            String
	 * @return int
	 */
	public static int toInt(String sNum) {
		try {
			return (int) toNumber(sNum);
		} catch (Exception e) {
			LogManager.getLogger(YssFun.class).log("转换字符串到 int 出错！", e);
			return 0;
		}
	}

	/**
	 * BigDeciaml 数字格式化处理
	 * 
	 * @param number
	 *            待格式化的数据
	 * @param format
	 *            格式化参数
	 * @return 格式化的字符串
	 */
	public static final String formatNumber(java.math.BigDecimal number,
			String format) {
		return (new java.text.DecimalFormat(format).format(number));
	}

	/**
	 * BigInteger 数字格式化处理
	 * 
	 * @param number
	 *            待格式化的数据
	 * @param format
	 *            格式化参数
	 * @return 格式化的字符串
	 */
	public static final String formatNumber(java.math.BigInteger number,
			String format) {
		return (new java.text.DecimalFormat(format).format(number));
	}

	/**
	 * 数字格式化，注意不一定四舍五入，有时候（偶数后的5）舍5！ 相当于vb中的format，不过只能是数字
	 */
	public static final String formatNumber(double number, String format) {
		return (new DecimalFormat(format)).format(number);
	}

	public static final String formatNumber(long number, String format) {
		return (new DecimalFormat(format)).format(number);
	}

	/**
	 * 数字取指定小数位数，默认四舍五入 如果bTranc=true则舍去下一位
	 */
	public static double roundIt(double val1, int lDecs, boolean bTrunc) {
		return YssD.round(val1, lDecs, bTrunc);
	}

	public static final double roundIt(double val1, int lDecs) {
		return roundIt(val1, lDecs, false);
	}

	/**
	 * 数值格式化函数，与formatNumber不同，这个可以保证四舍五入！ 另有同名的日期格式化函数，以兼容原vb下的同名函数
	 */
	public static String roundF(double val1, String sForm) {
		int ldec = 2;
		String stmp;
		boolean percent = false;

		// 先round再format
		if (sForm.length() != 0) {
			stmp = sForm.trim();
			if (stmp.charAt(stmp.length() - 1) == '%') {
				stmp = stmp.substring(0, stmp.length() - 1).trim();
				percent = true;
			}
			ldec = stmp.indexOf(".");
			if (ldec >= 0) {
				ldec = stmp.length() - ldec - 1;
			} else {
				ldec = 0;

			}
			if (percent) {
				ldec += 2;
			}
			val1 = roundIt(val1, ldec);
		}

		return new DecimalFormat(sForm).format(val1);
	}

	public static final String roundF(Date val1, String sForm) {
		return formatDate(val1, sForm);
	}

	// 字符串类函数********************************************************************
	/** java可以实现left,right,mid，可是如果超过长度，会报错，这里提供容错版本 */
	public static final String left(String sSrc, int iLen) {
		if (iLen >= sSrc.length()) {
			return sSrc;
		}
		return sSrc.substring(0, iLen);
	}

	public static final String right(String sSrc, int iLen) {
		if (iLen >= sSrc.length()) {
			return sSrc;
		}
		return sSrc.substring(sSrc.length() - iLen);
	}

	public static final String mid(String sSrc, int iStart, int iLen) {
		if (iStart + iLen >= sSrc.length()) {
			return sSrc.substring(iStart);
		}
		return sSrc.substring(iStart, iStart + iLen);
	}

	public static final String mid(String sSrc, int iStart) {
		return sSrc.substring(iStart);
	}

	/**
	 * 去除字符串尾部空格
	 * 
	 * @param sSrc
	 *            String：源串
	 * @return String：去除尾部空格后的结果
	 */
	public static final String rTrim(String sSrc) {
		int i;

		for (i = sSrc.length() - 1; i >= 0; i--) {
			if (sSrc.charAt(i) != ' ') {
				break;
			}
		}
		if (i < 0) {
			return "";
		}
		return sSrc.substring(0, i + 1);
	}

	/**
	 * 去除字符串开头空格
	 * 
	 * @param sSrc
	 *            String：源串
	 * @return String：去除开头空格后的结果
	 */
	public static final String lTrim(String sSrc) {
		int len = sSrc.length();
		int i;

		for (i = 0; i < len; i++) {
			if (sSrc.charAt(i) != ' ') {
				break;
			}
		}
		if (i >= len) {
			return "";
		}
		return sSrc.substring(i);
	}

	/**
	 * 去除字符串首尾的空格
	 * 
	 * @param sSrc
	 *            String：源串
	 * @return String：去除空格后的结果串
	 */
	public static final String trim(String sSrc) {
		int i, j;
		// 去除尾部空格
		for (i = sSrc.length() - 1; i >= 0; i--) {
			if (sSrc.charAt(i) != ' ') {
				break;
			}
		}
		if (i < 0) {
			return "";
		}
		// 去除开头空格
		for (j = 0; j < i; j++) {
			if (sSrc.charAt(j) != ' ') {
				break;
			}
		}
		return sSrc.substring(j, i + 1); // 返回从j到i的字符
	}

	/**
	 * 其实string的split方法，如果limit参数为负数，也可以显示这一功能，只是默认是0
	 * 
	 * 代替java的String类的split方法，即使最后以分隔符结束，也能正确返回最后的空串
	 * 
	 * @param sSrc
	 *            String：要split的原始串
	 * @param delimiter
	 *            String：分隔符
	 * @return String[]：返回字符串数组
	 */
	public static final String[] split(String sSrc, String delimiter) {
		String[] sarr;
		int l, len;

		sarr = java.util.regex.Pattern.compile(delimiter, 0).split(sSrc + " ",
				0);
		l = sarr.length - 1;
		len = sarr[l].length();
		if (len <= 1) {
			sarr[l] = "";
		} else {
			sarr[l] = sarr[l].substring(0, len - 1);
		}
		return sarr;
	}

	/**
	 * 将指定范围的数组元素组合起来成一个字符串
	 * 
	 * @param sArr
	 *            String[]
	 * @param delimiter
	 *            String：连接字符
	 * @param iStart
	 *            int：起始元素位置
	 * @param iEnd
	 *            int：截止元素
	 * @return String：组合成的字符串
	 */
	public static final String join(String[] sArr, String delimiter,
			int iStart, int iEnd) {
		StringBuffer buf = new StringBuffer();

		for (int i = (iStart != 0 ? iStart : 0); i < (iEnd != 0 ? iEnd + 1
				: sArr.length); i++) {
			buf.append(delimiter).append(sArr[i]);

		}
		return (buf.length() > 0 && delimiter.length() > 0 ? buf
				.substring(delimiter.length()) : buf.toString());
	}

	public static final String join(String[] sArr, String delimiter, int iStart) {
		return join(sArr, delimiter, iStart, 0);
	}

	public static final String join(String[] sArr, String delimiter) {
		return join(sArr, delimiter, 0, 0);
	}

	// 取得本月最大日期
	public static Date yssGetMaxDate(int year, int month) throws YssException {
		GregorianCalendar cl = null;
		try {
			cl = new GregorianCalendar();
			cl.setTime(new Date());
			cl.set(year, month - 1, YssFun.endOfMonth(year, month));

		} catch (Exception ex) {
			throw new YssException("日期转换错误！", ex);
		}
		return cl.getTime();
	}

	// 取得本月最小日期
	public static Date yssGetMinDate(int year, int month) throws YssException {
		GregorianCalendar cl = null;
		try {
			cl = new GregorianCalendar();
			cl.setTime(new Date());
			cl.set(year, month - 1, 1);

		} catch (Exception ex) {
			throw new YssException("日期转换错误！", ex);
		}
		return cl.getTime();
	}

	public static String getCheckStateName(int iCheckState) {
		String sResult = "";
		if (iCheckState == 0) {
			sResult = "未审核";
		} else if (iCheckState == 1) {
			sResult = "已审核";
		} else if (iCheckState == -1) {
			sResult = "回收站";
		}
		return sResult;
	}

	public static String getImpExpType(int iType) {
		String sResult = "";
		if (iType == 0) {
			sResult = "导入";
		} else if (iType == 1) {
			sResult = "导出";
		}
		return sResult;
	}

	// 读取文本文件
	public static String loadTxtFile(String sFileName) throws YssException {
		java.io.File ff = null;
		java.io.FileInputStream fi = null;
		int i = 0, j = 0;
		int size = -1;
		try {
			ff = new java.io.File(sFileName);
			fi = new java.io.FileInputStream(ff);

			size = (int) ff.length();
			byte[] fb = new byte[size];

			while (i < size) {
				j = fi.read(fb, i, size - i);
				if (j < 0) {
					break;
				}
				i += j;
			}
			return new String(fb, "UTF-8");
		} catch (Exception e) {
			throw new YssException("读取文件【" + sFileName + "】错误", e);
		} finally {
			ff = null;
			try {
				if(fi != null)
					fi.close();
			} catch (IOException ex) {
			}
			fi = null;
		}
	}

	/**
	 * 获取一个字符中的参数
	 * 
	 * @param str
	 *            String
	 * @param sP1
	 *            String：标识字符1
	 * @param sP2
	 *            String：标识字符2
	 * @return String：返回字符中存在的参数，中间用","分开
	 */
	public static String getStrParams(String str, String sP1, String sP2)
			throws YssException {
		String sParams = "";
		int iFrom = 0;
		int iEnd = -1;
		if (str.length() == 0 || str.equalsIgnoreCase("null")) {
			return "";
		}
		while (iFrom != -1) {
			iFrom = str.indexOf(sP1, iFrom);
			iEnd = str.indexOf(sP2, iFrom);
			if (iEnd == -1 && iFrom > 0) {
				throw new YssException("没有找到与【" + sP1 + "】相匹配的【" + sP2 + "】字符");
			}
			if (iEnd > -1 && iFrom != -1) {
				sParams += str.substring(iFrom + 1, iEnd) + ",";
				iFrom = iEnd;
			}
		}
		if (sParams.length() > 1) {
			sParams = sParams.substring(0, sParams.length() - 1);
		}
		return sParams;
	}

	public static String getStrParams(String str) throws YssException {
		return getStrParams(str, "<", ">");
	}

	// 根据标识把字符中的字符擦去
	protected String wipeStr(String str) {
		int iBIndex = -1;
		int iLen = 0;
		boolean bFlag = false;
		char[] chrAry = str.toCharArray();
		for (int i = 0; i < chrAry.length; i++) {
			if (chrAry[i] == '[') {
				iBIndex = i;
				iLen++;
			}
			if (iBIndex > -1) {
				iLen++;
			}
			if (iLen > 0
					&& ((chrAry[i] == '<' && chrAry[i + 2] == '>') || (chrAry[i] == '<' && chrAry[i + 3] == '>'))) {
				bFlag = true;
			}
			if (chrAry[i] == ']') {
				iLen++;
				if (bFlag) {
					for (int j = iBIndex; j < iBIndex + iLen - 2; j++) {
						chrAry[j] = ' ';
					}
				} else {
					chrAry[iBIndex] = ' ';
					chrAry[i] = ' ';
				}
				bFlag = false;
				iBIndex = -1;
				iLen = 0;
			}
		}
		return String.valueOf(chrAry);
	}

	/**
	 * 解析 <AAA:解析> 这种字符串 返回字符串中的 AAA 参见新财务系统中的变量定义的解析 by leeyu 20090910
	 * 
	 * @param str
	 *            String
	 * @return String
	 * @throws YssException
	 */
	public static String PatternSplitStrParams(String str) throws YssException {
		return Pattern.compile("<([^:<>]*):[^:<>]*>").matcher(str).replaceAll(
				"$1");
	}
	
	/**
	 * <code>getEveStockDate<code>介绍<br>
	 * 拼写V4.5系统取上一库存日期(当前日期减一日)的SQL的方法。<br>
	 * 所涉及到的字段为 D_Stock与C_Year_Month <br>
	 * 若日期为YYYY年1月1日时，当取年初库数据时日期字段不变年月字段取YYYY00数据；
	 *                        当取非年初日期库存时日期字段不变年月字段取不等于YYYY00数据；<br>
	 * 若日期为非YYYY年1月1日时，日期字段取值为d_Date-1日，年月字段取d_Date-1的YYYYMM的数据。                      
	 * @param dbl 当前连接库，作用是用于转换格式化SQL代码。
	 * @param d_Date 待处理的日期，注：这里的日期请不要先减一，方法中会自动减一。
	 * @param isBefOfYear 是否年初数标记，值为true：表示年初数，值为false：表示取1月1日库存。
	 * @return 返回字符串内容为“ and C_Year_Month= x and D_Stock= y”
	 * @author leeyu V4.5.0.1 2011-9-17
	 * @throws YssException
	 */
	public static final String getEveStockDateSQL(
			java.util.Date d_Date, boolean isBefOfYear) throws YssException {
		String strSql = "";
		if (getMonth(d_Date) == 1 && getDay(d_Date) == 1) {
			if (isBefOfYear) {
				strSql = " and C_Year_Month ='" + formatDate(d_Date, "yyyy")
						+ "00'";
			} else {
				strSql = " and C_Year_Month ='" + formatDate(d_Date, "yyyyMM")
						+ "'";
			}
			strSql = strSql
					+ (" and D_Stock = To_DATE('" + YssFun.formatDate(d_Date) + "','yyyy-MM-dd')"); // 1月1号不变
		} else {
			strSql = " and C_Year_Month ='"
					+ formatDate(addDay(d_Date, -1), "yyyyMM") + "'"
					+ " and D_Stock = TO_DATE('"
					+ YssFun.formatDate(addDay(d_Date, -1)) + "','yyyy-MM-dd') ";
		}
		return strSql;
	}
	
	/**
	 * By Jinghehe 根据日期获取 所在月的月底日期
	 * @param dDate
	 * @return
	 */
	public static Date endOfDate(Date dDate) {
		GregorianCalendar cl = new GregorianCalendar();
		cl.setTime(dDate);
		cl.set(Calendar.DATE, 1); 
		cl.add(Calendar.DATE, -1);    
		return cl.getTime();
	}
	
	/**
	 * 根据对象的某个字段比较对象的大小
	 * 
	 * @param pojoList
	 *            需要排序的对象列表
	 * @param field
	 *            对象的某个字段
	 * @param direction
	 *            从大到小或从小到大的方向
	 * @return 返回有序的对象列表
	 */
	@SuppressWarnings("unchecked")
	public static <T extends BasePojo> List<T> getSortPojoList(
			List<T> pojoList, String field, String direction) {
		BasePojo[] array = new BasePojo[2];

		// 冒泡排序法
		for (int i = 0; i < pojoList.size(); i++) {
			for (int j = 0; j < pojoList.size() - 1; j++) {
				array[0] = pojoList.get(j);
				array[1] = pojoList.get(j + 1);
				array = compareObjByField(array, field, direction);
				pojoList.set(j, (T) array[0]);
				pojoList.set(j + 1, (T) array[1]);
			}
		}

		return pojoList;
	}
	
	/**
	 * 根据对象的某个字段比较对象的大小
	 * 
	 * @param pojo
	 *            对象实例
	 * @param field
	 *            对象的某个字段
	 * @param direction
	 *            从大到小或从小到大的方向
	 * @return 返回有序对象列表
	 */
	public static BasePojo[] compareObjByField(BasePojo[] pojoArr,
			String field, String direction) {
		BasePojo[] sortPojoArr = new BasePojo[2];
		try {
			Field compareField = ReflectionUtil.getFieldWithSuperClass(
					pojoArr[0].getClass(), field);
			// 设置私有类型的字段可访问
			compareField.setAccessible(true);
			// BigDecimal类型
			if (compareField.getType().equals(BigDecimal.class)) {
				BigDecimal cmpFirst = (compareField.get(pojoArr[0]) == null ? BigDecimal.ZERO
						: (BigDecimal) compareField.get(pojoArr[0]));
				BigDecimal cmpSecond = (compareField.get(pojoArr[1]) == null ? BigDecimal.ZERO
						: (BigDecimal) compareField.get(pojoArr[1]));
				if ("DESC".equalsIgnoreCase(direction)) {
					if (cmpFirst.compareTo(cmpSecond) >= 0) {
						sortPojoArr[0] = pojoArr[0];
						sortPojoArr[1] = pojoArr[1];
					} else {
						sortPojoArr[0] = pojoArr[1];
						sortPojoArr[1] = pojoArr[0];
					}
				} else if ("ASC".equalsIgnoreCase(direction)) {
					if (cmpFirst.compareTo(cmpSecond) >= 0) {
						sortPojoArr[0] = pojoArr[1];
						sortPojoArr[1] = pojoArr[0];
					} else {
						sortPojoArr[0] = pojoArr[0];
						sortPojoArr[1] = pojoArr[1];
					}
				}
			} else if (compareField.getType().equals(String.class)) {
				// String类型
				String cmpFirst = (compareField.get(pojoArr[0]) == null ? ""
						: (String) compareField.get(pojoArr[0]));
				String cmpSecond = (compareField.get(pojoArr[1]) == null ? ""
						: (String) compareField.get(pojoArr[1]));
				if ("DESC".equals(direction)) {
					if (cmpFirst.compareToIgnoreCase(cmpSecond) > 0) {
						sortPojoArr[0] = pojoArr[0];
						sortPojoArr[1] = pojoArr[1];
					} else {
						sortPojoArr[0] = pojoArr[1];
						sortPojoArr[1] = pojoArr[0];
					}
				} else if ("ASC".equals(direction)) {
					if (cmpFirst.compareToIgnoreCase(cmpSecond) > 0) {
						sortPojoArr[0] = pojoArr[1];
						sortPojoArr[1] = pojoArr[0];
					} else {
						sortPojoArr[0] = pojoArr[0];
						sortPojoArr[1] = pojoArr[1];
					}
				}
			} else if (compareField.getType().equals(int.class)) {
				Integer cmpFirst = (compareField.get(pojoArr[0]) == null ? 0
						: (Integer) compareField.get(pojoArr[0]));
				Integer cmpSecond = (compareField.get(pojoArr[1]) == null ? 0
						: (Integer) compareField.get(pojoArr[1]));
				if ("DESC".equalsIgnoreCase(direction)) {
					if (cmpFirst.compareTo(cmpSecond) >= 0) {
						sortPojoArr[0] = pojoArr[0];
						sortPojoArr[1] = pojoArr[1];
					} else {
						sortPojoArr[0] = pojoArr[1];
						sortPojoArr[1] = pojoArr[0];
					}
				} else if ("ASC".equalsIgnoreCase(direction)) {
					if (cmpFirst.compareTo(cmpSecond) >= 0) {
						sortPojoArr[0] = pojoArr[1];
						sortPojoArr[1] = pojoArr[0];
					} else {
						sortPojoArr[0] = pojoArr[0];
						sortPojoArr[1] = pojoArr[1];
					}
				}
			} else if (compareField.getType().equals(double.class)) {
				Double cmpFirst = (compareField.get(pojoArr[0]) == null ? 0
						: (Double) compareField.get(pojoArr[0]));
				Double cmpSecond = (compareField.get(pojoArr[1]) == null ? 0
						: (Double) compareField.get(pojoArr[1]));
				if ("DESC".equalsIgnoreCase(direction)) {
					if (cmpFirst.compareTo(cmpSecond) >= 0) {
						sortPojoArr[0] = pojoArr[0];
						sortPojoArr[1] = pojoArr[1];
					} else {
						sortPojoArr[0] = pojoArr[1];
						sortPojoArr[1] = pojoArr[0];
					}
				} else if ("ASC".equalsIgnoreCase(direction)) {
					if (cmpFirst.compareTo(cmpSecond) >= 0) {
						sortPojoArr[0] = pojoArr[1];
						sortPojoArr[1] = pojoArr[0];
					} else {
						sortPojoArr[0] = pojoArr[0];
						sortPojoArr[1] = pojoArr[1];
					}
				}
			}

		} catch (Exception e) {
			LogManager.getLogger(YssFun.class).log("比较对象大小出错！", e);
		}

		return sortPojoArr;
	}
	
		/**
	 * 根据保留位数，截位方式进行数据截位处理  合并20.3.1分支代码
	 * @param value 数值
	 * @param jwlx 截位方式
	 * @param blws 保留位数
	 * @return
	 */
	public static double formatValue(double value, String jwlx, int blws) {
		if(jwlx.equalsIgnoreCase("JW_TRUNC")){
			// 截位
			value = YssFun.roundIt(value, blws, true);
		}
		else if(jwlx.equalsIgnoreCase("JW_ZSFR")){
			// 正舍负入
			if(value<0){
				value = YssFun.roundIt(value, blws, false);
			}
			else{
				value = YssFun.roundIt(value, blws, true);
			}
		}
		else{
			// 四舍五入
			value = YssFun.roundIt(value, blws, false);
		}
		return value;
	}
		/**
	 * 判断闰年当前日期是否在2月29 之后 包括2月29
	 * BY Jinghehe 2015-11-29 
	 * @param date
	 * @return
	 */
	public static boolean isAfter2And29(Date date) {
		boolean flag = false;
		if (formatDate(date, "MMdd").compareTo("0229") >= 0) {
			flag = true;
		}  
		
		return flag;
	}
}

 

转载于:https://my.oschina.net/u/3237893/blog/829727