工具类StringUtil

/**
 * Copyright (c) 2008 CEPRI,Inc.All rights reserved.
 * Created by 2008-4-25
 */
package com.cepri.cmm.utils;

/**
 * @title :字符串常用操作
 * @description :字符串常用操作公共方法
 * @data:
 */
public class StringUtil {

	/***************************************************************************
	 * java字符串相应类型的处理
	 **************************************************************************/
//过滤通过页面表单提交的字符   
       private static String[][] FilterChars={{"<","&lt;"},{">","&gt;"},{" ","&nbsp;"},{"\"","&quot;"},{"&","&amp;"},   
                                       {"/","&#47;"},{"\\","&#92;"},{"\n","<br>"}};   
       //过滤通过javascript脚本处理并提交的字符   
       private static String[][] FilterScriptChars={{"\n","\'+\'\\n\'+\'"},   
                                                           {"\r"," "},{"\\","\'+\'\\\\\'+\'"},   
                                                                   {"\'","\'+\'\\\'\'+\'"}}; 

	/**
	 * @description: 补充字符的方法,1、direction的取值为r(在原字符串右边补充)，l(在原字符串左边补充)
	 * @param oldStr
	 *            ：原字符串
	 * @param strLen
	 *            ：返回字符串长度
	 * @param padChar
	 *            ：插入字符串
	 * @param direction
	 *            ：插入方向
	 * @return
	 */
	public static String padString(String oldStr, int strLen, char padChar,
			char direction) {
		String newStr = oldStr;
		try {
			if (oldStr.length() >= strLen) {
				newStr = oldStr;
			} else {
				if (direction == 'r') {
					while (newStr.length() < strLen) {
						newStr = newStr + padChar;
					}
				} else {
					while (newStr.length() < strLen) {
						newStr = padChar + newStr;
					}
				}
			}
			return newStr;
		} catch (Exception e) {
			return oldStr;
		}
	}

	/** 提供字符串到Vector的转变 * */
	public static Vector Str2Vect(String tStr, String sStr) {
		Vector vector = new Vector();
		StringTokenizer st = new StringTokenizer(tStr, sStr);
		while (st.hasMoreTokens()) {
			vector.add(st.nextToken());
		}
		return vector;
	}

	/** 提供Vector到字符串的转变，转变后的字符串以sStr作为分割符 * */
	public static String Vect2Str(Vector tVect, String sStr) {
		String reStr = "";
		if (tVect.size() > 0)
			reStr = (String) tVect.get(0);
		for (int i = 1; i < tVect.size(); i++) {
			reStr += sStr + (String) tVect.get(i);
		}
		return reStr;
	}

	/** 提供Vector到字符串的转变，转变后的字符串没有分割符 * */
	public static String Vect2Str(Vector tVect) {
		String reStr = "";
		for (int i = 0; i < tVect.size(); i++) {
			reStr += (String) tVect.get(i);
		}
		return reStr;
	}

	/** 提供字符串到字符串数组的转变,转变后的字符串以sStr作为分割符 * */
	public static String[] Str2Strs(String tStr, String sStr) {
		StringTokenizer st = new StringTokenizer(tStr, sStr);
		String[] reStrs = new String[st.countTokens()];
		int n = 0;
		while (st.hasMoreTokens()) {
			reStrs[n] = st.nextToken();
			n++;
		}
		return reStrs;
	}
	/**
	 * 将以separator分割的字符串str按cnt个拆分开
	 * @return String[]
	 * @author Administrator
	 * 2009-12-3
	 */
		public static String[] subStrToArray(String str,String separator,int cnt) {
			String[] arr = StringUtil.Str2Strs(str, separator);
			String[] ar = null;
			if (arr.length > cnt) {
				int num = (arr.length % cnt) > 0 ? 1 : 0;
				ar = new String[arr.length / cnt + num];
				int sta = 0;
				int end = (arr[0].length() + 1) * cnt - 1;
				for (int i = 0; i < ar.length; i++) {
					ar[i] = str.substring(sta, end);
					sta = end + 1;
					end = sta +(arr[0].length() + 1) * cnt - 1;
					if(sta> str.length()){
						break;
					}
					if (end > str.length()) {
						end = str.length();
						ar[i+1] = str.substring(sta, end);
						break;
					}
				}
			}else{
				 ar =new String[1];
				 ar[0]=str;
			}
			return ar;
		}
	/** 提供字符串数组到字符串的转变，转变后的字符串以sStr作为分割符 * */
	public static String Strs2Str(String[] tStrs, String sStr) {
		String reStr = "";
		int len = tStrs.length;
		if (len > 0) {
			if (tStrs[0] != null)
				reStr = tStrs[0];
		}
		for (int i = 1; i < len; i++) {
			if (tStrs[i] != null) {
				if (tStrs[i].length() > 0)
					reStr += sStr + tStrs[i];
			}
		}
		return reStr;
	}

	/** 提供字符串数组到字符串的转变，转变后的字符串以sStr作为分割符,每个元素用''包含 * */
	public static String Strs2Str(String[] tStrs, String sStr, String tostr) {
		String reStr = "";
		int len = tStrs.length;
		if (len > 0) {
			if (tStrs[0] != null)
				reStr = "'" + tStrs[0] + "'";
		}
		for (int i = 1; i < len; i++) {
			if (tStrs[i] != null) {
				if (tStrs[i].length() > 0)
					reStr += sStr + "'" + tStrs[i] + "'";
			}
		}
		return reStr;
	}
	public static double numberDecimal(double d,int i){
		BigDecimal b=new BigDecimal(d);
    	 BigDecimal  bd1=b.setScale(i,b.ROUND_HALF_UP);
         d=bd1.doubleValue();
		return d;
	}

	/** 字符串数组到字符串的转变，转变后的字符串没有分割符 * */
	public static String Strs2Str(String[] tStrs) {
		String reStr = "";
		int len = tStrs.length;
		for (int i = 0; i < len; i++) {
			if (tStrs[i] != null) {
				if (tStrs[i].length() > 0)
					reStr += tStrs[i];
			}
		}
		return reStr;
	}

	/** 字符串以指定长度进行切割，结果放入Vector对象中 * */
	public Vector Str2Vect(String tStr, int nleng) {
		int strLength = tStr.length();
		int ndiv = strLength / nleng;
		Vector reVect = new Vector();
		if (strLength % nleng == 0)
			ndiv--;
		for (int i = 0; i < (ndiv); i++) {
			reVect.add(tStr.substring(i * nleng, (i + 1) * nleng));
		}
		reVect.add(tStr.substring(ndiv * nleng, strLength));
		return reVect;
	}

	/** 字符串相除，如果产生异常，返回"-" * */
	public static String Divide(String a, String b) {
		try {
			return String.valueOf(Double.valueOf(a).doubleValue()
					/ Double.valueOf(b).doubleValue());
		} catch (Exception e) {
			return "-";
		}
	}

	/** 字符串相除 如果产生异常，返回re * */
	public static String Divide(String a, String b, String re) {
		try {
			return String.valueOf(Double.valueOf(a).doubleValue()
					/ Double.valueOf(b).doubleValue());
		} catch (Exception e) {
			return re;
		}
	}

	/** 字符串相减，如果产生异常，返回re * */
	public static String decrease(String a, String b, String re) {
		try {
			return String.valueOf(Double.valueOf(a).doubleValue()
					- Double.valueOf(b).doubleValue());
		} catch (Exception e) {
			return re;
		}
	}

	/** 字符串相减，如果产生异常，返回a * */
	public static String decrease(String a, int b) {
		try {
			return String.valueOf(Integer.valueOf(a).intValue()
					- Integer.valueOf(b).intValue());
		} catch (Exception e) {
			return a;
		}
	}

	/** 字符串相减，如果产生异常，返回a * */
	public static String decrease(String a, String b) {
		try {
			return String.valueOf(Double.valueOf(a).doubleValue()
					- Double.valueOf(b).doubleValue());
		} catch (Exception e) {
			return a;
		}
	}

	/** 字符串减一 如果产生异常，返回a * */
	public static String decrease(String a) {
		try {
			return String.valueOf(Double.valueOf(a).doubleValue() - 1);
		} catch (Exception e) {
			return a;
		}
	}

	/** 字符串相加 如果产生异常，返回re * */
	public static String adding(String a, String b, String re) {
		try {
			return String.valueOf(Double.valueOf(a).doubleValue()
					+ Double.valueOf(b).doubleValue());
		} catch (Exception e) {
			return re;
		}
	}

	/** 字符串相加 如果产生异常，返回a * */
	public static String adding(String a, String b) {
		try {
			return String.valueOf(Double.valueOf(a).doubleValue()
					+ Double.valueOf(b).doubleValue());
		} catch (Exception e) {
			return a;
		}
	}

	/** 字符串加一 如果产生异常，返回a * */
	public static String adding(String a) {
		try {
			return String.valueOf(Double.valueOf(a).doubleValue() + 1);
		} catch (Exception e) {
			return a;
		}
	}

	/** 字符串相乘 如果产生异常，返回re * */
	public static String multiply(String a, String b, String re) {
		try {
			return String.valueOf(Double.valueOf(a).doubleValue()
					* Double.valueOf(b).doubleValue());
		} catch (Exception e) {
			return re;
		}
	}

	/** 字符串相乘 如果产生异常，返回a * */
	public static String multiply(String a, String b) {
		try {
			return String.valueOf(Double.valueOf(a).doubleValue()
					* Double.valueOf(b).doubleValue());
		} catch (Exception e) {
			return a;
		}
	}

	/** 字符串(a-b)/b 如果产生异常，返回re * */
	public static String Tqb(String a, String b, String re) {
		try {
			return String.valueOf((Double.valueOf(a).doubleValue() - Double
					.valueOf(b).doubleValue())
					/ (Double.valueOf(b).doubleValue()));
		} catch (Exception e) {
			return re;
		}
	}

	/** 字符串(a-b)/b 如果产生异常，返回"-" * */
	public static String Tqb(String a, String b) {
		try {
			return String.valueOf((Double.valueOf(a).doubleValue() - Double
					.valueOf(b).doubleValue())
					/ (Double.valueOf(b).doubleValue()));
		} catch (Exception e) {
			return "-";
		}
	}

	/** 将String 替换操作，将str1替换为str2 * */
	public static String replace(String str, String str1, String str2) {
		int n = -1;
		String subStr = "";
		String re = "";
		if ((n = str.indexOf(str1)) > -1) {
			subStr = str.substring(n + str1.length(), str.length());
			re = str.substring(0, n) + str2 + replace(subStr, str1, str2);
		} else {
			re = str;
		}
		return re;
	}

	/** 将字符串转换成Utf-8编码格式 * */
	public static String toUtf8String(String s) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);
			if (c >= 0 && c <= 255) {
				sb.append(c);
			} else {
				byte[] b;
				try {
					b = Character.toString(c).getBytes("utf-8");
				} catch (Exception ex) {
					System.out.println(ex);
					b = new byte[0];
				}
				for (int j = 0; j < b.length; j++) {
					int k = b[j];
					if (k < 0)
						k += 256;
					sb.append("%" + Integer.toHexString(k).toUpperCase());
				}
			}
		}
		return sb.toString();
	}

	/** 将字符串转换成GBK编码格式 * */
	public static String toGbkString(String s) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);
			if (c >= 0 && c <= 255) {
				sb.append(c);
			} else {
				byte[] b;
				try {
					b = Character.toString(c).getBytes("GBK");
				} catch (Exception ex) {
					System.out.println(ex);
					b = new byte[0];
				}
				for (int j = 0; j < b.length; j++) {
					int k = b[j];
					if (k < 0)
						k += 256;
					sb.append("%" + Integer.toHexString(k).toUpperCase());
				}
			}
		}
		return sb.toString();
	}

	/**
	 * 用给定的分隔符对字符串进行拆分，并生成数组
	 * 
	 * @param message
	 *            需要拆分的字符串
	 * @param separator
	 *            分隔符
	 * @return 生成的数组
	 */
	public static String[] splitToArray(String message, String separator) {
		List list = new ArrayList();
		int start = 0;
		int index = 0;
		while ((index = message.indexOf(separator, start)) != -1) {
			list.add(message.substring(start, index));
			start = index + separator.length();
		}

		if (start < message.length()) {
			list.add(message.substring(start, message.length()));
		}

		return (String[]) list.toArray(new String[list.size()]);
	}

	/** 将字符串转换为java.sql.date类型,str的格式必须匹配给定的格式formatStr * */
	public static java.sql.Date str2SqlDate(String str, String formatStr) {
		java.sql.Date sqlDate = new java.sql.Date(0);// 默认获得当前时间
		try {
			sqlDate = new java.sql.Date(new java.text.SimpleDateFormat(
					formatStr).parse(str).getTime());
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return sqlDate;
	}

	/** 将对象的返回的值不能为空 */
	public static String clear(Object obj) {
		if (null == obj || "null".equals(obj))
			return "";
		return obj.toString();
	}
	
	/** 将对象的返回的值不能为空，否则返回0*/
	public static String clearToZero(Object obj) {
		if (null == obj)
			return "0";
		return obj.toString();
	}
	/** 若对象为空返回指定的值 */
	public static String clear(Object obj, String value) {
		if (null == obj)
			return value;
		return obj.toString();
	}

	/** 判断对象的值是否为空 */
	public static boolean isNull(Object obj) {
		boolean flag = false;
		if (null == obj || "".equals(obj))
			flag = true;
		return flag;

	}

	/** 判断对象的值是否为空 */
	public static boolean isNotNull(Object obj) {
		boolean flag = true;
		if (null == obj || "".equals(obj))
			flag = false;
		return flag;

	}

	public static boolean isNotNull(List l) {
		if (null != l && l.size() > 0)
			return true;
		return false;
	}

	public static boolean isNotNull(String str) {
		if (null != str && str.trim().length() > 0)
			return true;
		return false;
	}

	public static boolean isNotNull(String[] str) {
		if (null != str && str.length > 0)
			return true;
		return false;
	}
	public static String replaceStrNullOrNot(String str) {
		if (null != str && str.length() > 0){
			return str;
		}
		else{
			return " ";
		}
	}
	
	public static String replaceStrNullOrNot(Object obj) {
		if (null != obj && !"".equals(obj)){
			return obj.toString();
		}
		else{
			return " ";
		}
	}
	/**
	 * 
	 * 方法名称:isNull
	 * <p>
	 * 方法描述:判断是字符串是否为空
	 * <p>
	 * 参数:
	 * 
	 * @param str
	 *            字符串 参数:
	 * @return boolean
	 *         <p>
	 *         <p>
	 * @author HJun
	 *         <p>
	 * @date Sep 2, 2009
	 *       <p>
	 */
	public static boolean isNull(String str) {
		if (null == str || "".equals(str.trim()))
			return true;
		return false;
	}

	/**
	 * 
	 * 方法名称:isNull
	 * <p>
	 * 方法描述: 判断结果集是否为空
	 * <p>
	 * 参数:
	 * 
	 * @param list
	 *            结果集对象 参数:
	 * @return boolean
	 *         <p>
	 *         <p>
	 * @author HJun
	 *         <p>
	 * @date Sep 2, 2009
	 *       <p>
	 */
	public static boolean isNull(List list) {
		if (null == list || list.size() == 0)
			return true;
		return false;
	}

	/**
	 * 
	 * 方法名称:isNull
	 * <p>
	 * 方法描述: 判断字符串数组是否为空
	 * <p>
	 * 参数:
	 * 
	 * @param str
	 *            String[] 字符串数组 参数:
	 * @return boolean
	 *         <p>
	 *         <p>
	 * @author HJun
	 *         <p>
	 * @date Sep 2, 2009
	 *       <p>
	 */
	public static boolean isNull(String[] str) {
		if (null == str || str.length == 0)
			return true;
		return false;
	}
	public static String translateToChinese(String str) {
		if(str!=null&&!"".equals(str)&&IsNumber(str)){
			return translateToChinese(Integer.parseInt(str));
		}else{
			return "0";
		}
		
	}
	/**
	 * @方法名 translate
	 * @功能 简单的数字转中文
	 * @param a
	 *            原始数字
	 * @return 中文字符串
	 */
	public static String translateToChinese(int a) {

		String[] units = { "", "十", "百", "千", "万", "十", "百", "千", "亿" };
		String[] nums = { "一", "二", "三", "四", "五", "六", "七", "八", "九", "十" };

		String result = "";
		if (a < 0) {
			result = "负";
			a = Math.abs(a);
		}
		String t = String.valueOf(a);
		for (int i = t.length() - 1; i >= 0; i--) {
			int r = (int) (a / Math.pow(10, i));
			if (r % 10 != 0) {
				String s = String.valueOf(r);
				String l = s.substring(s.length() - 1, s.length());
				result += nums[Integer.parseInt(l) - 1];
				result += (units[i]);
			} else {
				if (!result.endsWith("零")) {
					result += "零";
				}
			}
		}
		String num = a + "";
		/*
		 * 因为方法对10-20之间的数字支持不好，比如11返回一十一，不能满足需求 所以这里单独判断
		 */
		if (a == 10) {
			return "十";
		} else if (a > 10 && a < 20) {
			return result.substring(1);
		} else if (num.endsWith("0")) {
			result = result.substring(0, result.length() - 1);
		}
		return result;
	}

	public static boolean eq(String str, Object o) {
		if (null != o && isNotNull(o)) {
			return o.equals(str);
		}
		return false;
	}

	public static boolean eq(Object o1, Object o2) {
		if (null == o1 || isNull(o1)) {
			if (o2 == null || isNull(o2)) {
				return true;
			} else {
				return false;
			}
		} else {
			return o1.equals(o2);
		}
	}

	public static void main(String[] args) {
		
		System.out.println(zero("222.02"));
		System.out.println(IsFloat("1"));
		
		System.out.println(mulite("1234.345","29.01234"));
		
	}

	/**
	 * @return String
	 * @author Administrator 2009-9-20
	 */
	public static String toString(List list) {
		StringBuffer reStr = new StringBuffer("");
		for (Object o : list) {
			reStr.append(o.toString());
			reStr.append(",");
		}
		return reStr.toString();
	}
	/**
	 * 截取字符串
	 * 
	 * @param src
	 *            待截取字符串
	 * @param num
	 *            截取长度
	 * @return 截取后的字符串
	 */
	public static String cutString(String src, int num) {
		if (isNull(src))
			return src;
		return src.substring(0, src.length() > num ? num : src.length());
	}
	
	
	public static double mulite(String str,String str2){
		double d1=Double.parseDouble(str);
		double d2=Double.parseDouble(str2);
		return d1*d2;
	}
	
	 /**
	 * @函数名称：IsNumber
	 * @功能描述：是否数字
	 * @param str：true表示是，false表示否
	 * @return：是或否
	 * @exception:   null 空指针异常
	 */
	 public static boolean IsNumber(String str){ 
		 Pattern pattern = Pattern.compile("[0-9]*");  
		 return pattern.matcher(str).matches();     
	 } 
	 
	 /**
		 * @函数名称：IsNumber
		 * @功能描述：是数值
		 * @param str：true表示是，false表示否
		 * @return：是或否
		 * @exception:   null 空指针异常
		 */
		 public static boolean IsFloat(String str){ 
			 Pattern pattern = Pattern.compile("\\d+[.]?\\d*");  
			 return pattern.matcher(str).matches();     
		 } 
		 
     public static String getRequestStr(HttpServletRequest request,String param){
    	 String result=request.getParameter(param);
    	 if(StringUtil.isNull(result)){
    		 result=(String)request.getAttribute(param);
    	 }
    	 if(StringUtil.isNull(result)){
    		 result="";
    	 }
    	 result=result.trim();
    	 return result;
     }
 	/**
 	 * XML字符串中不能用这些字符 < > ' " &
 	 * 
 	 * @param str
 	 *            待转换的字符串
 	 * @return String 转换后的字符串
 	 * @author zhangg
 	 */
 	public static String replace4XML(String str) {
 		if (str == null)
 			return "";
 		return str.replace("<", "&lt;").replace(">", "&gt;").replace("'", "&apos;").replace("\"",
 				"&quot;").replace("&", "&amp;");
 	}

			
	/**和“WebContent/skins/default/js/sotowerfunction.js”里的方法“tag2code()”是一对，需要一起修改
	* @函数名称：HtmlTag2String
	* @功能描述：转换html符号为字符
	* @param：String
	* @return：String
	*/
	public static String HtmlTag2String(String temp){
		temp = temp==null?"":temp;
		return temp.replace("-lt;", "<").replace("-gt;", ">").replace("-amp;", "&");
	}
	
	/**
	 * 
	 * 方法名称：zero
	 * 方法描述：设置小数，前面没有0增加0
	 * @param str
	 * @return
	 * @return String
	 * @author HJun    
	 * @version 1.0
	 * Dec 17, 2009
	 */
	public static String zero(String str){
		if(str.startsWith(".")){
			str="0".concat(str);
		}
		return str;
	}
	
	/**
	* @函数名称：String2HtmlTag
	* @功能描述：转换“<”、“>”为html符号
	* @param：String
	* @return：String
	*/
	public static String String2HtmlTag(String temp){
		temp = temp==null?"":temp;
		return temp.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace("\"", "&quot;").replace("'", "&acute;");
	}
	
		 /**
			 * split("separator",'a') returns {"sep","r","tor"}
			 * @函数名称：convertToUTF8
			 * @功能描述：方法描述拆分字符串
			 * @param src
			 * @param char
			 * @return <br>
			 */
			public static String[] split(String src, char separator) {

				if (src == null)
					return null;
				else
					src = src.trim();
				int sprtCount = count(src, separator);
				if (sprtCount == 0) {
					String[] det = new String[1];
					det[0] = src;
					return det;
				}
				String[] det = new String[sprtCount + 1];
				int indexs = 0, indexe = 0;
				for (int i = 0; i <= sprtCount; i++) {
					indexe = src.indexOf(separator, indexs);
					if (indexe == -1)
						det[i] = src.substring(indexs);
					else {
						det[i] = src.substring(indexs, indexe);
						indexs = indexe + 1;
					}
				}
				return det;
			}
			/**
			 * @函数名称：count
			 * @功能描述：方法描述个数
			 * @param pStr
			 *            String
			 * @return String
			 */
			public static int count(String ptr, char c) {
				int coun = 0, pos = 0;
				while ((pos = ptr.indexOf(c, pos)) != -1) {
					coun++;
					pos++;
				}
				return coun;
			}
			/**
			 * @函数名称：count
			 * @功能描述：方法描述个数
			 * @param pStr
			 *            String
			 * @param c String
			 * @return String
			 */
			public static int count(String ptr, String c) {
				int coun = 0, pos = 0;
				while ((pos = ptr.indexOf(c, pos)) != -1) {
					coun++;
					pos += c.length();
				}
				return coun;
			}
			/**
			 * @函数名称：getDoubleXDigit
			 * @功能描述：保留X位小数
			 * @param obj String
			 * @param x double
			 * @return double
			 */
			public static double getDoubleXDigit(String obj,double x) {
				double tmpD = Double.parseDouble(obj);
				double y = 10;
				y = Math.pow(y, x);
				tmpD = tmpD * y;
				tmpD = Math.round(tmpD);
				tmpD = tmpD / y;
				return tmpD;
			}

			public static String getReplaceStr(String str,String regStr){
			      Pattern p = Pattern.compile(regStr);
			      Matcher m = p.matcher(str);
			      str = m.replaceAll("");
			      return str;
			}
		
			public static String getBackName (String  fileName){
				if(isNull(fileName)) return "";
				if(fileName.lastIndexOf(".") < 0) return "";
				return fileName.substring(fileName.lastIndexOf("."));
			}
 
			public static String getGBK(String str,String code){
				try {
					return new String(str.getBytes(),code);
				} catch (UnsupportedEncodingException e) {
					return null;
				}
			}

			/**
			 * 方法名称：getRequestStr
			 * 方法描述：
			 * @param context
			 * @param string
			 * @return
			 * @return String
			 * @version 1.0
			 */
			public static String getRequestStr(WebContext context, String param) {
				HttpServletRequest request=WebcUtils.getRequest(context);
				return getRequestStr(request, param);
			}
			
	/** 提供字符串到ArrayList的转变 * */
	public static List<String> str2List(String tStr, String sStr) {
		if(isNull(tStr)){
			return null;
		}
		List<String> list = new ArrayList<String>();
		StringTokenizer st = new StringTokenizer(tStr, sStr);
		while (st.hasMoreTokens()) {
			list.add(st.nextToken());
		}
		return list;
	}
	
	/**
	 * 方法名称：
	 * 方法描述：
	 * @param context
	 * @version 1.0
	 */
	public static List<Map<String, String>> compareObj(Object obj1,Object obj2) throws Exception {
        Class c = obj1.getClass();
        Field fields[] = c.getDeclaredFields();
        List<Map<String, String>> clist = new ArrayList<Map<String, String>>();
        
        for (Field field :fields) {
            field.setAccessible(true);
            Object val1 = invokeMethod(obj1,field.getName(),null);
            Object val2 = invokeMethod(obj2,field.getName(),null);
            System.out.println(field.getName()+" : val1="+val1+"---割割割割----val2="+val2);
        if(val1!=null&&val2!=null){
        	if(!val1.equals(val2)){
            	Map<String, String> ma = new HashMap<String, String>();
            	ma.put("beforValue", val1.toString());
            	ma.put("afterValue", val2.toString());
            	ma.put("colomnCode", convertString(field.getName()));
            //	ma.put("tableCode", c.getName());
            	clist.add(ma);
            }
        	
        }
//        else if(val1==null){
//                if(val2!=null){
//                   // return true;
//                }else{ 
//                	
//                }
//            }
//            
            
        }
        return clist;

    }
	/**
	 * 方法名称：
	 * 方法描述：
	 * @param context
	 * @version 1.0
	 */
    public static Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
        Class ownerClass = owner.getClass();
        System.out.println("Method="+methodName);
        methodName = methodName.substring(0, 1).toUpperCase() + methodName.substring(1);
        Method method = null;
        try {
        method = ownerClass.getMethod("get" + methodName);
      
        } catch (SecurityException e) {
        } catch (NoSuchMethodException e) {
        return " can't find 'get" + methodName + "' method";
        }

        return method.invoke(owner);
        }
    /**
	 * 方法名称：
	 * 方法描述：
	 * @param context
	 * @version 1.0
	 */
public static String convertString(String s){
	if(isNotNull(s)){
	char[] c = s.toCharArray();
	String str ="";
	int i =0;
	for(char ch : c){
		if(Character.isUpperCase(ch)&&i>0){
			str+="_";
		}
		str+=ch;
		i++;
	}
	return str;
	}else{
		return "";
	}
}

public static String convertString1(String s){
	if(isNotNull(s)){
	String ss = s.toLowerCase();
	char[] carr = ss.toCharArray();
	String str ="";
	char temp = 0;
	for(int i = 0; i < carr.length; i++){
		if(i>0)temp = carr[i-1];
		if(Character.isLetter(carr[i]) && temp == '_' ){
			 str += (carr[i]+"").toUpperCase();
		}else{
			str += carr[i];
		}
	}
	str = str.replace("_", "");
	return str;
	}else{
		return "";
	}
}
/**
 * 
 * @author zhangling
 * 在模糊查询中过滤容易引发SQL语句执行异常的符号
 */
public static String ReplaceSqlLike(String strQuery)
{
    String strRet = strQuery;
    strRet = strRet.replace("/","//");
    strRet = strRet.replace("'","''");
    strRet = strRet.replace("%","/%");
    strRet = strRet.replace("[","/[");
    strRet = "'%" + strRet + "%' escape '/'";
    return strRet;
}
/**
 * 
 * @return返回时间格式字符串。按年，月
 */
public static String getDirName(){
	SimpleDateFormat df = new SimpleDateFormat("yyyyMM");
	Date date = new Date();
	return df.format(date);
}

 /**  
        * 用特殊的字符连接字符串  
        * @param strings 要连接的字符串数组  
        * @param spilit_sign 连接字符  
        * @return 连接字符串  
        */  
       public static String stringConnect(String[] strings,String spilit_sign){   
    	   StringBuffer str=new StringBuffer();   
         for(int i=0;i<strings.length;i++){   
        	 str.append(strings[i]);
        	 str.append(spilit_sign);
         }   
         return str.toString();   
       }   
  
       /**  
        * 过滤字符串里的的特殊字符  
        * @param str 要过滤的字符串  
        * @return 过滤后的字符串  
        */  
       public static String stringFilter(String str){   
         String[] str_arr=stringSpilit(str,"");   
         for(int i=0;i<str_arr.length;i++){   
           for(int j=0;j<FilterChars.length;j++){   
             if(FilterChars[j][0].equals(str_arr[i]))   
               str_arr[i]=FilterChars[j][1];   
           }   
         }   
         return (stringConnect(str_arr,"")).trim();   
       }   
  
       /**  
* 过滤脚本中的特殊字符（包括回车符(\n)和换行符(\r)）  
* @param str 要进行过滤的字符串  
* @return 过滤后的字符串  
*/  
public static String stringFilterScriptChar(String str){   
String[] str_arr=stringSpilit(str,"");   
for(int i=0;i<str_arr.length;i++){   
   for (int j = 0; j < FilterScriptChars.length; j++) {   
     if (FilterScriptChars[j][0].equals(str_arr[i]))   
       str_arr[i] = FilterScriptChars[j][1];   
   }   
}   
return(stringConnect(str_arr,"")).trim();   
}   
  
  
       /**  
        * 分割字符串  
        * @param str 要分割的字符串  
        * @param spilit_sign 字符串的分割标志  
        * @return 分割后得到的字符串数组  
        */  
       public static String[] stringSpilit(String str,String spilit_sign){   
         String[] spilit_string=str.split(spilit_sign);   
         if(spilit_string[0].equals(""))   
         {   
           String[] new_string=new String[spilit_string.length-1];   
           for(int i=1;i<spilit_string.length;i++)   
             new_string[i-1]=spilit_string[i];   
             return new_string;   
         }   
         else  
           return spilit_string;   
       }   
  
       /**  
        * 字符串字符集转换  
        * @param str 要转换的字符串  
        * @return 转换过的字符串  
        */  
       public static String stringTransCharset(String str){   
         String new_str=null;   
         try{   
             new_str=new String(str.getBytes("iso-8859-1"),"GBK");   
	         }   
	         catch(Exception e){   
	           e.printStackTrace();   
	         }   
	         return new_str;   
	       }   
	  
	       /**  
	        * 测试字符串处理类  
	        * @param args 控制台输入参数  
	        */  
	       public static void main(String[] args){   
	  
	         //测试字符串过滤   
	         String t_str1="<h1>StringDispose字符串 处理\n\r\'\"</h1>";   
	         System.out.println("过滤前："+t_str1);   
	         System.out.println("过滤后："+StringUtils.stringFilter(t_str1));   
	         //测试合并字符串   
	         String[] t_str_arr1={"PG_1","PG_2","PG_3"};   
	         String t_str2=StringUtils.stringConnect(t_str_arr1,",");   
	         System.out.println(t_str2);   
	         //测试拆分字符串   
	         String[] t_str_arr2=StringUtils.stringSpilit(t_str2,",");   
	         for(int i=0;i<t_str_arr2.length;i++){   
	           System.out.println(t_str_arr2[i]);   
	         }   
	       }

}