package com.fengqi.wechat.utils;

import com.google.common.collect.Maps;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.Map.Entry;

/**
 * 常用字符串操作
 */
public class EasyStr {
	
	public static boolean isEmpty(String value)
	{
		return nil(value);
	}
	
	public static boolean isNotEmpty(String value)
	{
		return !nil(value);
	}
	
	/**
	 * 判断字符串是否为Null或空字符串
	 * @param String 要判断的字符串
	 * @return boolean
	 */
	public static boolean nil(String s) {
		return s == null || s.trim().equals("");
	}
	
	/**
	 * 字符串数组转换为字符串,使用逗号分隔
	 * String s = {"Micheal","David","Wendy"};
	 * EasyStr.join(s,","); //-> "Micheal,David,Wendy"
	 * @param String[]
	 * @param String
	 * @return String
	 */
	public static String join(String[] s,String sp){
		if(EasyStr.nil(s)) return "";
		if(s.length==1) return s[0];
		StringBuffer sb = new StringBuffer();
		for(int i=0;i<s.length;i++){
			sb.append(s[i]).append(sp);
		}
		if(!EasyStr.nil(sp))
			sb.deleteCharAt(sb.lastIndexOf(sp));
		return sb.toString();
	}
	
	/**
	 * 当第一个字符串不为空则返回第一个字符串,否则返回第二个
	 * @param String
	 * @param String
	 * @return String
	 */
	public static String nil(String s, String _default) {
		return EasyStr.nil(s)? _default:s;
	}
	
	/**
	 * 判断字符串数组是否为空
	 * @param String
	 * @return boolean
	 */
	public static boolean nil(String[] s){
		return (s==null || s.length==0);
	}
	
	/**
	 * 改变字符串编码到UTF-8
	 * @param String
	 * @return String
	 */
	public static String toUTF(String src){
		if(nil(src)) return "";
	    String s = null;
		try {
			s = new String(src.getBytes("ISO-8859-1"),"UTF-8");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
	    return s;
	}
	
	/**
	 * 改变字符串编码到UTF-8
	 * @param StringBuffer
	 * @return String
	 */
	public static String toGBK(StringBuffer src){
		return toUTF(src.toString());
	}

	/**
	 * 改变字符串为指定编码
	 * @param String encode
	 * @param String src
	 * @return String
	 */
	public static String trans(String encode, String src){
		if(nil(src)) return "";
	    String s = null;
		try {
			s = new String(src.getBytes("ISO-8859-1"),encode);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
	    return s;
	}
	
	/**
	 * 改变字符串为指定编码
	 * @param String encode
	 * @param String src
	 * @return String
	 */
	public static String trans(String encode, StringBuffer src){
	    return trans(encode,src.toString());
	}
	
	/**
	 * 转换String到boolean
	 * null或""时返回false
	 * "1"返回true,"0"返回false
	 * "是"返回true,"否"返回false
	 * "yes"返回true,"no"返回false
	 */
	public static boolean parseBoolean(String flag){
		if(nil(flag)) return false;
		else if(flag.equals("1") || flag.equalsIgnoreCase("true") || flag.equals("是") || flag.equalsIgnoreCase("yes"))return true;
		else if(flag.equals("0") || flag.equalsIgnoreCase("false") || flag.equals("否") || flag.equalsIgnoreCase("no"))return false;
		return false;
	}

	/**
	 * 转换int到boolean,参数为1时返回true,否则返回false
	 * @param i 0=false,1=true
	 */
	public static boolean parseBoolean(int i){
		return i==1;
	}

	/**
	 * 转换String到int
	 * null或"",返回0
	 * "true"返回1,"false"返回0
	 * "123"返回123
	 * @param String
	 * @return int
	 */
	public static int parseInt(String flag){
		if(nil(flag)) return 0;
		else if(flag.equalsIgnoreCase("true")) return 1;
		else if(flag.equalsIgnoreCase("false")) return 0;
		else if(flag.equalsIgnoreCase("null")) return 0;
		try{
			return Integer.parseInt(flag);
		}catch(NumberFormatException e){
			e.printStackTrace();
		}
		return 0;
	}
	
	/**
	 * 转换String到long
	 * null或""返回0
	 */
	public static long parseLong(String flag){
		if(nil(flag)) return 0;
		return Long.parseLong(flag);
	}
	
	/**
	 * 转换String到float
	 * null或""返回0
	 */
	public static float parseFloat(String flag){
		if(nil(flag)) return 0;
		return Float.parseFloat(flag);
	}

	/**
	 * 转换String到byte
	 * null或""返回0
	 */
	public static byte parseByte(String flag) {
		if(nil(flag)) return 0;
		return Byte.parseByte(flag);
	}

	/**
	 * 转换字符串数组返回一个整数数组
	 * @param String[]
	 * @return int[]
	 */
	public static int[] parseInt(String[] s) throws NumberFormatException{
		if (s == null) {
			return (new int[0]);
		}
		int[] result = new int[s.length];
		for (int i = 0; i < s.length; i++) {
			result[i] = parseInt(s[i]);
		}
		return result;
	}
	
	private static final DecimalFormat df = new DecimalFormat("#.0000");
	
	/**
	 * 转换科学计数法格式的浮点类型到普通格式
	 * @param srcDouble 源数字
	 * @return result 转换后的格式
	 */
	public static String withoutSN(double d){
		return df.format(d);
	}
	
	/**
	 * 将字串转成日期，字串格式: yyyy-MM-dd
	 * @param String
	 * @return Date
	 */
	public static Date parseDate(String string) {
		try {
			DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
			return (Date) formatter.parse(string);
		} catch (Exception ex) {
			ex.printStackTrace();
			return null;
		}
	}
	
	/**
	 * 字符填充,fill("123","0",6,-1); //->"000123"; fill("123","0",6,1); //->"123000"
	 * @param source 源字符串
	 * @param filler 填充字符,如0或*等
	 * @param length 最终填充后字符串的长度
	 * @param local 位置,-1表示在在字符串前面填充,1表示在字符串后面填充
	 * @return 最终填充后字符串
	 */
	public static String fill(String source,String filler,int length,int local) {
		StringBuffer sb = null;
		if(local==-1){
			sb = new StringBuffer();
			for(int i=0;i<length-source.length();i++){
				sb.append(filler);
			}
			sb.append(source);
		}else if(local==1){
			sb = new StringBuffer(source);
			while(sb.length()<length){
				sb.append(filler);
			}
		}
		return sb.toString();
	}
	
	/**
	 * 字符填充,fill("123","0",6); //->"000123"
	 * @param source 源字符串
	 * @param filler 填充字符,如0或*等
	 * @param length 最终填充后字符串的长度
	 * @return 最终填充后字符串
	 */
	public static String fill(String source,String filler,int length){
		return fill(source, filler, length, -1);
	}
	
	/**
	 * 遍历数组中所有的字符串,从开头到分隔符进行截取,返回截取后的数组. 
	 * String arr[] = {"Micheal Wazowski","John Leno"}; 
	 * subStrBefore(arr," "); //-> {"Micheal","John"}
	 * @param arr 源字符串数组
	 * @param spliter 切割符
	 * @return 切割后的字符串数组
	 */
	public static String[] subStrBefore(String[] arr,String spliter){
		for(int i=0;i<arr.length;i++){
			arr[i]=arr[i].substring(0,arr[i].indexOf(spliter));
		}
		return arr;
	}

	/**
	 * 判断数组中是否包含指定的值。大小写敏感。
	 * @param strings 字符串数组
	 * @param string 字符串
	 * @return 包含时返回true，否则返回false
	 */

	public static boolean contains(String[] strings, String string) {
		return contains(strings, string, true);
	}

	/**
	 * 判断数组中是否包含指定的值。大小写敏感。
	 * @param arr 源数组
	 * @param n 要查找的值
	 * @return 包含时返回true，否则返回false
	 */

	public static boolean contains(int[] arr, int n) {
		for (int i=0,l=arr.length;i<l;i++) {
			if (n==arr[i]) return true;
		}
		return false;
	}

	/**
	 * 字符串数组中是否包含指定的字符串。
	 * @param strings 字符串数组
	 * @param string 字符串
	 * @param caseSensitive 是否大小写敏感
	 * @return 包含时返回true，否则返回false
	 */

	public static boolean contains(String[] strings, String string,boolean caseSensitive) {
		for (int i = 0; i < strings.length; i++) {
			if (caseSensitive == true) {
				if (strings[i].equals(string)) {
					return true;
				}
			} else {
				if (strings[i].equalsIgnoreCase(string)) {
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * 不区分大小写判定字符串数组中是否包含指定的字符串。
	 * @param strings 字符串数组
	 * @param string 字符串
	 * @return 包含时返回true，否则返回false
	 */

	public static boolean containsIgnoreCase(String[] strings, String string) {
		return contains(strings, string, false);
	}
	/**
	 * 转换字符串数组返回一个浮点数组
	 * @param String[]
	 * @return float[]
	 */
	public static float[] parseFloat(String[] s) throws NumberFormatException{
		if (s == null) {
			return (new float[0]);
		}
		float[] result = new float[s.length];
		for (int i = 0; i < s.length; i++) {
			result[i] = Float.parseFloat(s[i]);
		}
		return result;
	}
	
	/**
	 * 分割字符串,返回整型数组
	 * @param String
	 * @return int[]
	 */
	public static int[] split(String s) {
		if(nil(s)) return new int[0];
		if(s.indexOf(",")>-1){
			return EasyStr.split(s,",");
		}else{
			int[] i = new int[1];
			i[0] = Integer.parseInt(s);
			return i;
		}
	}
	
	/**
	 * 分割字符串,返回整型数组
	 * @param String
	 * @param String 分隔符如逗号
	 * @return int[]
	 */
	public static int[] split(String s,String spliter) throws NumberFormatException{
		if (s == null || s.indexOf(spliter)==-1) {
			return (new int[0]);
		}
		String[] ary = s.split(spliter);
		int[] result = new int[ary.length];
		for (int i = 0; i < ary.length; i++) {
			result[i] = Integer.parseInt(ary[i]);
		}
		return result;
	}
	
	/**
	 * 将整型数组合并为用字符分割的字符串
	 * @param int[]
	 * @return String
	 */
	public static String join(int[] arr){
		if(arr==null || arr.length==0) return "";
		StringBuffer sb = new StringBuffer();
		for(int i=0,len=arr.length;i<len;i++){
			sb.append(",").append(arr[i]);
		}
		sb.deleteCharAt(0);
		return sb.toString();
	}
	
	/**
	 * 删除StringBuffer最后一个字符,一般用于StringBuffer链接字符串后,删除最后一个逗号
	 * @param StringBuffer
	 * @param String
	 * @return StringBuffer
	 */
	public static StringBuffer deleteLast(StringBuffer sb, String s){
		if(sb==null || sb.length()==0) 
			return sb;
		
		int i = sb.lastIndexOf(s);
		if(i>-1) sb.deleteCharAt(i);
		return sb;
	}
	
	/**
	 * 将指定字符串复制n次,如EasyStr.times("echo ",3) //=> echo echo echo ;
	 * @param src 源字符串
	 * @param n 复制次数
	 * @return rst 复制结果
	 */
	public static String times(String src,int n){
		if(n<1) return "";
		StringBuffer sb = new StringBuffer();
		for(--n; n>-1; sb.append(src),n--){}
		return sb.toString();
	}
	
	/**
	 * 生成长度为n的字符串数组,且每一项的值都为src
	 * @param src 源字符串
	 * @param n 数组长度
	 * @return rst 生成的数组
	 */
	public static String[] arrayTimes(String src,int n){
		if(n<1) return new String[0];
		String[] rst = new String[n];
		for(--n; n>-1; rst[n] = src,n--){}
		return rst;
	}
	
	/**
	 * 英文日期格式
	 */
	public final static int ENGLISH_DATE = 0;
	/**
	 * 中文日期格式
	 */
	public final static int CHINESE_DATE = 1;
	
	/**
	 * 短日期格式,2008-01-01
	 */
	public final static int SHORT_DATE = 2;
	
	/**
	 * 仅时间,10:10:10
	 */
	public final static int ONLY_TIME = 3;
	
	private static String[] types = {
		"yyyy-MM-dd HH:mm:ss",		//ENGLISH_DATE
		"yyyy年MM月dd日HH时mm分ss秒",	//CHINESE_DATE
		"yyyy-MM-dd",				//SHORT_DATE
		"HH:mm:ss"					//ONLY_TIME
	};
	
	/**
	 * 获取当前系统日期,格式为yyyy-MM-dd hh:mm:ss或yyyy年MM月dd日hh时mm分ss秒
	 * @param 类型,0-2008-08-08 08:08:08; 1-2008年08月08日08时08分08秒;
	 * @return 当前系统日期
	 */
	public static String now(int i){
		return new SimpleDateFormat(types[i]).format(new Date());
	}
	
	public static String now(){
		return now(ENGLISH_DATE);
	}
	
	public static String today(){
		return now(SHORT_DATE);
	}
	
	/**
	 * 获取服务器当前时间中的年
	 * @return year 今年
	 */
	public static int year(){
		return Calendar.getInstance().get(Calendar.YEAR);
	}
	
	/**
	 * 获取服务器当前时间中的月
	 * @return month 月
	 */
	public static int month(){
		return Calendar.getInstance().get(Calendar.MONTH)+1;
	}
	
	/**
	 * 获取服务器当前时间中的日
	 * @return dayOfMonth 日
	 */
	public static int dayOfMonth(){
		return Calendar.getInstance().get(Calendar.DAY_OF_MONTH);
	}
	
	/***
	 * 一个红色的*号的HTML代码
	 */
	public final static String REDSTAR = "<span style='color:red;'>*</span>";
	
	/**
	 * URL字符串解码: 中文 -> %D6%D0%CE%C4
	 */
	public static String decode(String s){
		try {
			return URLDecoder.decode(s, "GBK");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return "";
	}

	/**
	 * URL字符串转码: %D6%D0%CE%C4 -> 中文
	 */
	public static String encode(String s){
		try {
			return URLEncoder.encode(s, "GBK");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return "";
	}

	/**
	 * 给定一个yyyy-MM-dd格式的日期字符串,加上n天,得出新的日期
	 * @param oldDate 原日期
	 * @param n 天数
	 * @return newDate 新日期
	 */
	public static String appendDate(String oldDate,int n){
		Calendar c = Calendar.getInstance();
		int[] ymd= EasyStr.parseInt(oldDate.split("-"));
		
		c.set(Calendar.YEAR, ymd[0]);
		c.set(Calendar.MONTH, ymd[1]-1);
		c.set(Calendar.DAY_OF_MONTH, ymd[2]);
		c.add(Calendar.DAY_OF_MONTH, n);
		
		String y = c.get(Calendar.YEAR)+"";
		
		String m = (c.get(Calendar.MONDAY)+1)+"";
		if(m.length()==1) m=0+m;
		
		String d = c.get(Calendar.DAY_OF_MONTH)+"";
		if(d.length()==1) d=0+d;

		return y+"-"+m+"-"+d;
	}
	
	/**
	 * 两个日期之间的天数
	 * @param date1 日期1
	 * @param date2 日期2
	 * @param is_abs 是否时绝对值
	 * @return n 天数
	 */
	public static int dateSpacing(String date1,String date2,boolean is_abs){
		Calendar c = Calendar.getInstance();
		int[] ymd1 = EasyStr.parseInt(date1.split("-"));
		c.set(Calendar.YEAR, ymd1[0]);
		c.set(Calendar.MONTH, ymd1[1]-1);
		c.set(Calendar.DAY_OF_MONTH, ymd1[2]);
		long m1 = c.getTimeInMillis();

		int[] ymd2 = EasyStr.parseInt(date2.split("-"));
		c.set(Calendar.YEAR, ymd2[0]);
		c.set(Calendar.MONTH, ymd2[1]-1);
		c.set(Calendar.DAY_OF_MONTH, ymd2[2]);
		long m2 = c.getTimeInMillis();
		
		if(is_abs)
			return Math.abs((int)((m2 - m1) / 86400000));
		else
			return (int)((m2 - m1) / 86400000);
	}
	
	/**
	 * 得到某年某月的第一天和最后一天
	 * @param year 年
	 * @param month 月
	 * @return firstNLastDay 第一天的日期和最后一天的日期,如EasyStr.firstAndLastDay(2008,2) -> ["2008-02-01","2008-02-29"]
	 */
	public static String[] firstAndLastDay(int year, int month){
		Calendar c = Calendar.getInstance();
		c.set(Calendar.YEAR, year);
		c.set(Calendar.MONTH, month-1);
		
		String _month = (month<10 ? "0":"")+month;
		
		int lastDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);
		
		return new String[]{year+"-"+_month+"-01", year+"-"+_month+"-"+lastDay};
	}

	/**
	 * 得到当月的第一天和最后一天
	 * @return firstNLastDay 第一天的日期和最后一天的日期,如["2008-02-01","2008-02-29"]
	 */
	public static String[] firstAndLastDay(){
		Calendar c = Calendar.getInstance();
		int year = c.get(Calendar.YEAR);
		int _month = c.get(Calendar.MONTH)+1;
		String month = (_month<10 ? "0":"")+_month;
		int lastDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);
		return new String[]{year+"-"+month+"-01", year+"-"+month+"-"+lastDay};
	}

	/**
	 * 得到当天的前几天和后几天的日期
	 * @param n 前n天
	 * @param m 后m天
	 * @return days[2] days[0]前n天的日期,days[1]后m天的日期
	 */
	public static String[] preAndNextDay(int n,int m){
		Calendar c = Calendar.getInstance();
		
		c.add(Calendar.DAY_OF_MONTH, -n);
		int month = c.get(Calendar.MONTH)+1;
		String _month = (month<10 ? "0":"")+month;
		int day = c.get(Calendar.DAY_OF_MONTH);
		String _day = (day<10 ? "0":"")+day;
		String pre = c.get(Calendar.YEAR)+"-"+_month+"-"+_day;
		
		c.add(Calendar.DAY_OF_MONTH, n+m);
		month = c.get(Calendar.MONTH)+1;
		_month = (month<10 ? "0":"")+month;
		day = c.get(Calendar.DAY_OF_MONTH);
		_day = (day<10 ? "0":"")+day;
		String next = c.get(Calendar.YEAR)+"-"+_month+"-"+_day;
		
		return new String[]{pre,next};
	}
	
	/**
	 * 汉字星期
	 */
	private static final String[] CN_WEEKS = new String[]{"日","一","二","三","四","五","六","七"};
	
	/**
	 * 获取当天是星期几
	 * @param chinese? true:中文,false:英文
	 * @return dayOfWeek 返回当天是星期几，chinese=true时返回“一”，chinese=false时返回"1"
	 */
	public static String todayInWeek(boolean chinese){
		Calendar c = Calendar.getInstance();
		int dow = c.get(Calendar.DAY_OF_WEEK) - 1;
		return chinese ? "星期"+CN_WEEKS[dow] : ""+dow;
	}
	
	/**
	 * 获取当天是星期几
	 * @return dayOfWeek 返回当天是星期几
	 */
	public static String todayInWeek(){
		return todayInWeek(false);
	}
   
   /**
    * 比较2个时间大小
    * @param DATE1
    * @param DATE2
    * @return
    */
   public static int compare_date(String DATE1, String DATE2) {
	       
	        DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm");
	        try {
	            Date dt1 = df.parse(DATE1);
	            Date dt2 = df.parse(DATE2);
	            if (dt1.getTime() > dt2.getTime()) {
	                return 1;
	            } else if (dt1.getTime() < dt2.getTime()) {
	              
	                return -1;
	            } else {
	                return 0;
	            }
	        } catch (Exception exception) {
	            exception.printStackTrace();
	        }
	        return 0;
	    }
	
	
	/**
	 * 判断两个日期范围之间是否有交集，日期格式必须为 2009-09-09，且必须是有效的日期
	 */
	public static boolean hasIntersection(String start_date1,String end_date1,String start_date2,String end_date2){
		int Y = Calendar.YEAR;
		int M = Calendar.MONTH;
		int D = Calendar.DAY_OF_MONTH;
		
		String[] dates = new String[]{start_date1,end_date1,start_date2,end_date2};
		long[] cs = new long[4];
		for(int i=0; i<dates.length; i++){
			String[] ds = dates[i].split("-");
			Calendar c = Calendar.getInstance();
			c.set(Y, Integer.parseInt(ds[0]));
			c.set(M, Integer.parseInt(ds[1])-1);
			c.set(D, Integer.parseInt(ds[2]));
			cs[i] = c.getTimeInMillis();
		}
		long tmp = 0;
		long s1 = cs[0];
		long e1 = cs[1];
		if(s1 > e1){
			tmp = e1;
			e1 = s1;
			s1 = tmp;
		}
		long s2 = cs[2];
		long e2 = cs[3];
		if(s2 > e2){
			tmp = e2;
			e2 = s2;
			s2 = tmp;
		}
		
		//判断交叉
		boolean flag = 
		//开始1<开始2,结束1<结束2,开始2<结束1
		(s1<=s2 && e1<=e2 && s2<=e1)||
		//开始2<开始1,结束2<结束1,开始1<结束2
		(s2<=s1 && e2<=e1 && s1<=e2)||
		//开始1<开始2,结束2<结束1
		(s1<=s2 && e2<=e1)||
		//开始2<开始1,结束1<结束2
		(s2<=s1 && e1<=e2);
		return flag;
	}
	/**
	 * JAVA类中输出JSON字符串
	 * @param response
	 * @param json
	 */
	public static void outJsonString(HttpServletResponse response, String json) {   
        response.setContentType("text/javascript;charset=UTF-8");  
        PrintWriter out;
		try {
			out = response.getWriter();
			out.write(json);
			out.flush();  
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}   
         
    }  
 /**
  * 日期字符转数值类型
  * @param String Data
  */
  public static int DateToNum( String date ){
	  String []  d = date.split("-");
	  String num ="" ;
	  for (int i = 0 ;i<d.length;i++){
		  num =num + d[i].toString();	  
	  }
	  return Integer.parseInt(num);  
  }
	
	 /**
	  * 打印堆栈的错误信息
	  * @param t
	  * @return
	  */
	 public static String getErrorStack(Exception e) {
		   if (e != null) {
            StringWriter sw = new StringWriter();
            PrintWriter pw = new PrintWriter(sw);
            e.printStackTrace(pw);
            return sw.toString();
         }
		return "";  
	 }
	 /**
	  * 生成随机长度的字符串
	  * @param length
	  * @return
	  */
	 public static String getRandomString(int length) { //length表示生成字符串的长度
		    String base = "abcdefghijklmnopqrstuvwxyz0123456789";   
		    Random random = new Random();   
		    StringBuffer sb = new StringBuffer();   
		    for (int i = 0; i < length; i++) {   
		        int number = random.nextInt(base.length());   
		        sb.append(base.charAt(number));   
		    }   
		    return sb.toString().toUpperCase();   
		 }   
  
	 /**
	  * 生成随机数字
	  * @param length
	  * @return
	  */
	 public static String getRandomNum(int length){
		 Random random = new Random();   
		 String result="";
		for(int i=0;i<length;i++){
		  result+=random.nextInt(10);
		}
		 return result ;
		    
	 }

		
		 /**
		 * 将驼峰式命名的字符串转换为下划线大写方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。</br>
		 * 例如：HelloWorld->HELLO_WORLD
		 * @param name 转换前的驼峰式命名的字符串
		 * @return 转换后下划线大写方式命名的字符串
		 */
		public static String underscoreName(String name) {
		    StringBuilder result = new StringBuilder();
		    if (name != null && name.length() > 0) {
		        // 将第一个字符处理成大写
		        result.append(name.substring(0, 1).toUpperCase());
		        // 循环处理其余字符
		        for (int i = 1; i < name.length(); i++) {
		            String s = name.substring(i, i + 1);
		            // 在大写字母前添加下划线
		            if (s.equals(s.toUpperCase()) && !Character.isDigit(s.charAt(0))) {
		                result.append("_");
		            }
		            // 其他字符直接转成大写
		            result.append(s.toUpperCase());
		        }
		    }
		    return result.toString();
		}
		
		/**
		 * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。</br>
		 * 例如：HELLO_WORLD->HelloWorld
		 * @param name 转换前的下划线大写方式命名的字符串
		 * @return 转换后的驼峰式命名的字符串
		 */
		public static String camelName(String name) {
		    StringBuilder result = new StringBuilder();
		    // 快速检查
		    if (name == null || name.isEmpty()) {
		        // 没必要转换
		        return "";
		    } else if (!name.contains("_")) {
		        // 不含下划线，仅将首字母小写
		        return name.substring(0, 1).toLowerCase() + name.substring(1);
		    }
		    // 用下划线将原始字符串分割
		    String camels[] = name.split("_");
		    for (String camel :  camels) {
		        // 跳过原始字符串中开头、结尾的下换线或双重下划线
		        if (camel.isEmpty()) {
		            continue;
		        }
		        // 处理真正的驼峰片段
		        if (result.length() == 0) {
		            // 第一个驼峰片段，全部字母都小写
		            result.append(camel.toLowerCase());
		        } else {
		            // 其他的驼峰片段，首字母大写
		            result.append(camel.substring(0, 1).toUpperCase());
		            result.append(camel.substring(1).toLowerCase());
		        }
		    }
		    return result.toString();
		}
		
		/**
		 * 转换mapkey为驼峰
		* @Title: changeMap  
		* @Description: TODO(这里用一句话描述这个方法的作用)  
		* @param @param prams
		* @param @return    参数  
		* @return Map<String,String>    返回类型  
		* @throws
		 */
		public static Map<String,String> changeMap( Map<String,String> prams){
			Map<String,String> newMap = Maps.newHashMap();
			Iterator<Entry<String, String>> it = prams.entrySet().iterator();  
		        while(it.hasNext()){  
		            Entry<String, String> itEntry = it.next();  
		            Object itKey = itEntry.getKey();  
		            Object itValue = itEntry.getValue();   
		            newMap.put(EasyStr.camelName(String.valueOf(itKey)), String.valueOf(itValue)); 
		     }
			return newMap;
		}
		
		
		/** 
		* @Title: StringSplitMap  
		* @Description: 根据分隔符生成map 格式 key=value^key=value 
		* @param @param content
		* @param @param splitString
		* @param @return    参数  
		* @return Map<String,String>    返回类型  
		* @throws
		 */
		public static Map<String,String> stringSplitMap(String  content,String splitString){
			Map<String,String> newMap = Maps.newHashMap();
			String[] maps= content.split("\\"+splitString);
			for(String str :maps){
				String []  m =str.split("=");
				newMap.put(m[0], m[1]);
			}
			return newMap;	
		}
		
		
		
}
