Java自定义StringUtil

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.codec.binary.Base64;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;

public class StringUtil {
   
	public static String trim(String value) {
		if (value == null) {
			return "";
		}
		return value.replaceAll("[\\s\\p{Zs}\n\t\\s*\r\\|]", "");
	}

	private static Pattern linePattern = Pattern.compile("_(\\w)");
	private static Pattern humpPattern = Pattern.compile("[A-Z]");
	
	/** 下划线转驼峰 */
	public static String lineToHump(String str) {
		str = str.toLowerCase();
		Matcher matcher = linePattern.matcher(str);
		StringBuffer sb = new StringBuffer();
		while (matcher.find()) {
			matcher.appendReplacement(sb, matcher.group(1).toUpperCase());
		}
		matcher.appendTail(sb);
		return sb.toString();
	}

	
    /**
         * 将下划线转换为驼峰的形式，例如：user_name-->userName
     */
    public static <T> T toSnakeObject(Object jsonObject, Class<T> clazz) throws IOException {
        if (jsonObject == null) {
            return null;
        }
        String json = JSONObject.toJSONString(jsonObject);
        ObjectMapper mapper = new ObjectMapper();
        // mapper的configure方法可以设置多种配置（例如：多字段 少字段的处理）
        // mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        mapper.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);
        T reqJson = mapper.readValue(json, clazz);
        return reqJson;
    }

	/** 驼峰转下划线 */
	public static String humpToLine2(String str) {
		Matcher matcher = humpPattern.matcher(str);
		StringBuffer sb = new StringBuffer();
		while (matcher.find()) {
			matcher.appendReplacement(sb, "_" + matcher.group(0).toLowerCase());
		}
		matcher.appendTail(sb);
		return sb.toString();
	}

	public static String secretIDN(String idn) {
		idn = trim(idn);
		if (idn == null) {
			return null;
		} else if ("".equals(trim(idn))) {
			return null;
		} else if (idn.length() == 15) {
			return idn.substring(0, 6) + "******" + idn.substring(12, 15);
		} else if (idn.length() == 18) {
			return idn.substring(0, 6) + "********" + idn.substring(14, 18);
		} else {
			return "身份证号码位数错误";
		}
	}

	public static String secretBankCard(String bankCard) {
		bankCard = trim(bankCard);
		int length = bankCard.length();
		if (length > 10) {
			return bankCard.substring(0, 6) + getLengthStr(length - 10) + bankCard.substring(length - 4, length);
		} else {
			return "不合格的银行卡/存折号";
		}
	}

	public static String secretMoblie(String moblie) {
		moblie = trim(moblie);
		int length = moblie.length();
		if (length > 7) {
			return moblie.substring(0, 3) + getLengthStr(length - 7) + moblie.substring(length - 4, length);
		} else {
			return null;
		}
	}

	private static String getLengthStr(int length) {
		String result = "";
		for (int i = 0; i < length; i++) {
			result += "*";
		}
		return result;
	}

	private static ThreadLocal<Integer> curTl = new ThreadLocal<>();

	public static Object mapStringToObject(String str) throws Exception {
		str = str.replaceAll(" ", "");
		curTl.set(0);
		Object returnObj = null;
		char c = str.charAt(curTl.get());
		curTl.set(curTl.get() + 1);
		switch (c) {
		case '{':
			returnObj = handleMap(str);
			break;
		case '[':
			returnObj = handleList(str);
			break;
		default:
			throw new Exception("解析错误,位置:" + (curTl.get() - 1));
		}
		return returnObj;
	}

	private static Map<String, Object> handleMap(String str) {
		StringBuffer curKey = new StringBuffer();
		Object curValue = null;
		// 1准备接收key2准备接收值
		int state = 1;
		Map<String, Object> resultMap = new HashMap<>();
		while (true) {
			char curChar = str.charAt(curTl.get());
			curTl.set(curTl.get() + 1);
			switch (state) {
			case 1:
				switch (curChar) {
				case '=':
					state = 2;
					curValue = null;
					break;
				default:
					curKey.append(curChar);
					break;
				}
				break;
			case 2:
				switch (curChar) {
				case '{':
					curValue = handleMap(str);
					resultMap.put(curKey.toString(), curValue);
					break;
				case '}':
					resultMap.put(curKey.toString(), curValue);
					return resultMap;
				case ',':
					if (curValue == null) {
						curValue = "";
					}
					resultMap.put(curKey.toString(), curValue);
					state = 1;
					curKey = new StringBuffer();
					curValue = null;
					break;
				case '[':
					curValue = handleList(str);
					resultMap.put(curKey.toString(), curValue);
					break;
				default:
					if (curValue == null) {
						curValue = "";
					}
					curValue = curValue.toString() + curChar;
					break;
				}
			}
		}
	}

	private static List<Map<String, Object>> handleList(String str) {
		List<Map<String, Object>> resultList = new ArrayList<>();
		Map<String, Object> curValue = null;
		while (true) {
			char curChar = str.charAt(curTl.get());
			curTl.set(curTl.get() + 1);
			switch (curChar) {
			case '{':
				curValue = handleMap(str);
				resultList.add(curValue);
				break;
			case ',':
				curValue = null;
				break;
			case ']':
				return resultList;
			}
		}
	}

	public static int charHash(String str) {
		int strLength = str.length();
		char[] c = new char[strLength];
		for (int i = 0; i < strLength; i++) {
			c[i] = str.charAt(i);
		}
		boolean hasChange = true;
		while (hasChange) {
			hasChange = false;
			for (int i = 0; i < strLength - 1; i++) {
				char cur = c[i];
				char next = c[i + 1];
				if (cur > next) {
					char t = cur;
					c[i] = c[i + 1];
					c[i + 1] = t;
					hasChange = true;
				}
			}
		}
		StringBuffer sb = new StringBuffer();
		for (char d : c) {
			sb.append(d);
		}
		return sb.toString().hashCode();
	}

	/**
	 * json 格式判断
	 * 
	 * @param str
	 * @return
	 */
	public static boolean isjson(String str) {
		if (StringUtil.isEmpty(str)) {
			return false;
		}
		try {
			JSONObject.parseObject(str);
			return true;
		} catch (Exception e) {
			return false;
		}
	}
	
	public static boolean isEmpty(Object str) {
		if (str==null) {
			return true;
		}
		return isEmpty(str.toString());
	}

	public static boolean isEmpty(String str) {
		if (str == null)
			return true;
		str = str.trim();
		if ("".equals(str))
			return true;
		if ("null".equals(str))
			return true;
		return false;
	}
	
	public static boolean isNotEmpty(Object str){
	if (str==null) {
		return false;
	}
	return isNotEmpty(str.toString());
}
	
	public static boolean isNotEmpty(String str){
        return !isEmpty(str);
    }

	public static List<String> sortStrings(Object... strings) {
		List<String> resultList = new ArrayList<>();
		while (true) {
			boolean changeFlag = false;
			for (int i = 0; i < strings.length - 1; i++) {
				if (strings[i].toString().compareTo(strings[i + 1].toString()) > 0) {
					Object t = strings[i];
					strings[i] = strings[i + 1];
					strings[i + 1] = t;
					changeFlag = true;
				}
			}
			if (!changeFlag) {
				break;
			}
		}
		for (Object string : strings) {
			resultList.add(string.toString());
		}
		return resultList;
	}
	
	public static double strToDouble(String str){
        double res = 0;
        if(isNum(str)){
            res = strToBigDecimal(str).doubleValue();
        }
        return res;
    }

    public static boolean strToBoolean(String s, boolean def){
        if (s != null && s.length() > 0) 
            return Boolean.parseBoolean(s);
        else
            return def;
    }

    public static BigDecimal strToBigDecimal(String str){
        BigDecimal res = new BigDecimal("0");
        try {
            res = res.add(new BigDecimal(str));
        } catch (Exception e) {
            res = new BigDecimal("0");
        }
        return res;
    }
    
    public static int strToInt(String str){
        int res=0;
        try {
            if(isNumeric(str)){
                res = Integer.parseInt(str);
            }
        } catch (Exception e) {
            res=0;
        }
        return res;
    }
    
    public static int strToInt(String str,int def){
        int res=def;
        try {
            if(isNumeric(str)){
                res = Integer.parseInt(str);
            }
        } catch (Exception e) {
            res = def;
        }
        return res;
    }
    
    /**
     * 是否为整数
     * @param str
     * @return
     */
    public static boolean isNumeric(String str){
        if(isEmpty(str)) return false;
        for (int i = 0; i < str.length(); i++){
            if (!Character.isDigit(str.charAt(i))){
                return false;
            }
        }
        return true;
    }
    
    /**
     * 是否为数值（包含整数和小数）
     * @param str
     * @return
     */
    public static boolean isNum(String str){
        if(!isNumeric(str)){
            try {
                new BigDecimal(str);
            } catch (Exception e) {
                return false;
            }
        }
        return true;
    }

    public static String obj2str(Object obj){
        return obj==null?"":obj.toString();
    } 
    
	public static int objToInt(Object obj,int def){
	if (obj==null) {
		return def;
	}
	return strToInt(obj.toString(), def);
}
    
	public static String toRespStr(Object o,String s) {
        return o != null ? toRespStr(o.toString()) : s;
    }
	
    public static String toRespStr(Object o) {
        return o != null ? toRespStr(o.toString()) : "";
    }
    
    public static String toRespStr(String s) {
        if (s == null) s = "";
        return s.trim();
    }
    
    public static String copyValue(String strings){
        if(strings==null)strings="";
        return String.copyValueOf(strings.toCharArray());
    }
    
	public static String getUUID(){
        return UUID.randomUUID().toString().replaceAll("-", "");
    }
	
	/**
     * sof111,sof222 字符串转 'sof111','sof222' 用于拼sql 单引号处理
     * spiltStringToAppendSql
     * @param str
     * @return
     */
    public static String spiltStringToAppendSql(String str) {
        if (isEmpty(str)) {
            return "";
        }
        StringBuffer sb = new StringBuffer();
        String[] temp = str.split(",");
        for (int i = 0; i < temp.length; i++) {
            if (!"".equals(temp[i]) && temp[i] != null)
                sb.append("'" + temp[i] + "',");
        }
        String result = sb.toString();
        String tp = result.substring(result.length() - 1, result.length());
        if (",".equals(tp))
            return result.substring(0, result.length() - 1);
        else
            return result;
    }
    
    public static Map<String, Object> jsonStrToMap(Object jsonStr) {
    	if (jsonStr==null) {
			return null;
		}
    	return jsonStrToMap(jsonStr.toString());
    }
	
    public static Map<String, Object> jsonStrToMap(String jsonStr) {
    	try {
			return JSONObject.parseObject(jsonStr , new TypeReference<Map<String, Object>>(){});
		} catch (Exception e) {
			return null;
		}
	}
    public static List<Map<String, Object>> jsonStrToList(Object jsonStr) {
        if (jsonStr==null){
        	return null;
		}
        return jsonStrToList(jsonStr.toString());
    }

	public static List<Map<String, Object>> jsonStrToList(String jsonStr) {
		try {
			return JSONObject.parseObject(jsonStr , new TypeReference<List<Map<String, Object>>>(){});
		} catch (Exception e) {
			return null;
		}

	}
    
    public static String base64Decode(String textEncoded) throws UnsupportedEncodingException {
        final Base64 base64 = new Base64();
        return new String(base64.decode(textEncoded), "UTF-8");
    }
    
    public static String getValueFromJson(JSONObject json,String key) {
        if (json==null) {
            return null;
        }
        if (StringUtil.isEmpty(key)) {
            return null;
        }
        return json.getString(key)==null?"":json.getString(key);
    }
    
    public static String getValueByKey(Map<String, ?> valueMap,String key) {
        if (valueMap!=null &&valueMap.containsKey(key) ) {
            return valueMap.get(key)+"";
        }else {
            return "";
        }
    }

    /**
     * 根据字符串长度 左右补0
     */
    public static String addZeroNumToString(String str, int strLength, String direction) {
        if (StringUtil.isEmpty(str)) {
            return null;
        }
        int strLengthValue = str.length();
        if (strLengthValue >= strLength) {
            return str;
        } else {
            while (strLengthValue < strLength) {
                StringBuffer stringBuffer = new StringBuffer();
                if ("left".equals(direction)) {
                    stringBuffer.append("0").append(str);
                } else {
                    stringBuffer.append(str).append("0");
                }
                str = stringBuffer.toString();
                strLengthValue = str.length();
            }
            return str;
        }
    }
    
    /** 
     * 判断是否为中文字符 
     */  
    public static boolean isChinese(char c) {  
        Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);  
        if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS  
                || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS  
                || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A  
                || ub == Character.UnicodeBlock.GENERAL_PUNCTUATION  
                || ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION  
                || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS) {  
            return true;  
        }  
        return false;  
    } 
    
    /**
     * unidecode 转中文
     */
    public static String decodeUnicode(String unicode) {     
        StringBuffer string = new StringBuffer();  
        
        String[] hex = unicode.split("\\\\u");  
  
        for (int i = 0; i < hex.length; i++) {  
              
            try {  
                // 汉字范围 \u4e00-\u9fa5 (中文)  
                if(hex[i].length()>=4){//取前四个，判断是否是汉字  
                    String chinese = hex[i].substring(0, 4);  
                    try {  
                        int chr = Integer.parseInt(chinese, 16);  
                        boolean isChinese = isChinese((char) chr);  
                        //转化成功，判断是否在  汉字范围内  
                        if (isChinese){//在汉字范围内  
                            // 追加成string  
                            string.append((char) chr);  
                            //并且追加  后面的字符  
                            String behindString = hex[i].substring(4);  
                            string.append(behindString);  
                        }else {  
                            string.append(hex[i]);  
                        }  
                    } catch (NumberFormatException e1) {  
                        string.append(hex[i]);  
                    }  
                      
                }else{  
                    string.append(hex[i]);  
                }  
            } catch (NumberFormatException e) {  
                string.append(hex[i]);  
            }  
        }  
        return string.toString();  
   }
    /**
              * 得到任意位数的数字验证码
     */
    public static synchronized String getRandStr(int n) {
        Random random = new Random();
        String sRand = "";
        for (int i = 0; i < n; i++) {
            String rand = String.valueOf(random.nextInt(10));
            sRand += rand;
        }
        return sRand;
    }
    
    public static String arrayToStr(String[] array) {
        if (array == null) {
            return null;
        }if (array.length == 0) {
            return null;
        }
        StringBuffer strBuff = new StringBuffer();
        for (String s : array) {
            strBuff.append(s);
        }
        return strBuff.toString();
    }
    
    public static String URLEncode(String str) {
        if (str == null || str.length() == 0) return str;
        try {
          return URLEncoder.encode(str, "UTF-8");
        } catch (Exception e) {
          return str; 
        }
   }
    
   public static String getRandomStr(int length) {
        String randomPool = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz";
        int poolLength = randomPool.length();
        StringBuffer stringBuffer = new StringBuffer();
        Random rand = new Random();
        for (int i = 0; i < length; i++) {
            stringBuffer.append(randomPool.charAt(rand.nextInt(poolLength)));
        }
        return stringBuffer.toString();
    }

	/**
	 * json 格式判断
	 * @param str
	 * @return
	 */
	public static boolean isjsonArray(String str){
		if (StringUtil.isEmpty(str)) {
			return false;
		}
		try {
			JSONObject.parseArray(str);
			return true;
		} catch (Exception e) {
			return false;
		}
	}

	public static boolean equalsStrings(String str,String... strArray){
		if (isNotEmpty(str)) {
			if (strArray.length > 0) {
				for (String temp : strArray) {
					if (temp.equals(str)) return true;
				}
			}
		}
		return false;
	}

	public static boolean equalsStrings(Object str,String... strArray){
		if (isNotEmpty(str)) {
			if (strArray.length > 0) {
				for (String temp : strArray) {
					if (temp.equals(str+"")) return true;
				}
			}
		}
		return false;
	}
	
	public static boolean isBoolean(Object str) {
		if (str==null) {
			return false;
		}
		return "true".equalsIgnoreCase(str.toString()) || "false".equalsIgnoreCase(str.toString());
	}
}