import org.apache.commons.lang3.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Random;
import java.util.Set;
import java.util.StringTokenizer;

/**
 * @ClassName：StringHelper
 * @Description： <p> ---字符串工具類---  </p>
 * @Author： - Jason
 * @CreatTime：2019/7/23 - 10:51
 * @Modify By：
 * @ModifyTime： 2019/7/23
 * @Modify marker：
 * @version V1.0
*/
public class StringHelper {

    public static Log logger = LogFactory.getLog(StringHelper.class);

    /**
     * 前導(dǎo)標(biāo)識(shí)
     */
    public static final int BEFORE = 1;

    /**
     * 后繼標(biāo)識(shí)
     */
    public static final int AFTER = 2;

    /**
     * DEFAULT_PATH_SEPARATOR
     */
    public static final String DEFAULT_PATH_SEPARATOR = ",";

    /**
     * EMPTY
     */
    public static final String EMPTY = "";

    /**
     * SLASH
     */
    public static final String SLASH = "/";

    /**
     * 將一個(gè)中間帶逗號(hào)分隔符的字符串轉(zhuǎn)換為ArrayList對(duì)象
     * @param str
     *            待轉(zhuǎn)換的符串對(duì)象
     * @return ArrayList對(duì)象
     */
    public static ArrayList<?> strToArrayList(String str) {
        return strToArrayListManager(str, DEFAULT_PATH_SEPARATOR);
    }

    /**
     * 將字符串對(duì)象按給定的分隔符separator轉(zhuǎn)象為ArrayList對(duì)象
     * @param str
     *            待轉(zhuǎn)換的字符串對(duì)象
     * @param separator
     *            字符型分隔符
     * @return ArrayList對(duì)象
     */
    public static ArrayList<String> strToArrayList(String str, String separator) {
        return strToArrayListManager(str, separator);
    }

    /**
     * @Description: 分割
     * @param str
     * @param separator
     * @return ArrayList<String>
     * @Autor: jasonandy@hotmail.com
     */
    private static ArrayList<String> strToArrayListManager(String str, String separator) {

        StringTokenizer strTokens = new StringTokenizer(str, separator);
        ArrayList<String> list = new ArrayList<String>();

        while (strTokens.hasMoreTokens()) {
            list.add(strTokens.nextToken().trim());
        }

        return list;
    }

    /**
     * 字符串是否為非空白 空白的定義如下： <br>
     * 1米辐、不為null <br>
     * 2、不為不可見(jiàn)字符（如空格）<br>
     * 3匹颤、不為""<br>
     * @param str 被檢測(cè)的字符串
     * @return 是否為非空
     */
    public static boolean isNotBlank(CharSequence str) {
        return false == isBlank(str);
    }

    /**
     * 字符串是否為空白 空白的定義如下： <br>
     * 1篷就、為null <br>
     * 2矫钓、為不可見(jiàn)字符（如空格）<br>
     * 3尖啡、""<br>
     * @param str 被檢測(cè)的字符串
     * @return 是否為空
     */
    public static boolean isBlank(CharSequence str) {
        int length;

        if ((str == null) || ((length = str.length()) == 0)) {
            return true;
        }
        for (int i = 0; i < length; i++) {
            /**
             * 只要有一個(gè)非空字符即為非空字符串
             */
            if (false == isBlankChar(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }


    /**
     * 編碼字符串
     * @param str 字符串
     * @param charset 字符集项玛，如果此字段為空荞估，則解碼的結(jié)果取決于平臺(tái)
     * @return 編碼后的字節(jié)碼
     */
    public static byte[] bytes(CharSequence str, Charset charset) {
        if (str == null) {
            return null;
        }
        if (null == charset) {
            return str.toString().getBytes();
        }
        return str.toString().getBytes(charset);
    }



    /**
     * 是否空白符<br>
     * 空白符包括空格咳促、制表符、全角空格和不間斷空格<br>
     * @param c 字符
     * @return 是否空白符
     * @see Character#isWhitespace(int)
     * @see Character#isSpaceChar(int)
     */
    public static boolean isBlankChar(char c) {
        return isBlankChar((int) c);
    }

    /**
     * 是否空白符<br>
     * 空白符包括空格勘伺、制表符跪腹、全角空格和不間斷空格<br>
     * @see Character#isWhitespace(int)
     * @see Character#isSpaceChar(int)
     * @param c 字符
     * @return 是否空白符
     */
    public static boolean isBlankChar(int c) {
        return Character.isWhitespace(c) || Character.isSpaceChar(c) || c == '\ufeff' || c == '\u202a';
    }

    /**
     * 將一個(gè)中間帶逗號(hào)分隔符的字符串轉(zhuǎn)換為字符型數(shù)組對(duì)象
     * @param str
     *            待轉(zhuǎn)換的符串對(duì)象
     * @return 字符型數(shù)組
     */
    public static String[] strToStrArray(String str) {
        return strToStrArrayManager(str, DEFAULT_PATH_SEPARATOR);
    }

    /**
     * 將字符串對(duì)象按給定的分隔符separator轉(zhuǎn)象為字符型數(shù)組對(duì)象
     * @param str  待轉(zhuǎn)換的符串對(duì)象
     * @param separator 字符型分隔符
     * @return 字符型數(shù)組
     */
    public static String[] strToStrArray(String str, String separator) {
        return strToStrArrayManager(str, separator);
    }

    /**
     * strToStrArrayManager
     * @param str
     * @param separator
     * @return
     */
    private static String[] strToStrArrayManager(String str, String separator) {
        StringTokenizer strTokens = new StringTokenizer(str, separator);
        String[] strArray = new String[strTokens.countTokens()];
        int i = 0;
        while (strTokens.hasMoreTokens()) {
            strArray[i] = strTokens.nextToken().trim();
            i++;
        }
        return strArray;
    }

    /**
     * strToSet
     * @param str
     * @return
     */
    public static Set<String> strToSet(String str) {
        return strToSet(str, DEFAULT_PATH_SEPARATOR);
    }

    /**
     * strToSet
     * @param str
     * @param separator
     * @return
     */
    public static Set<String> strToSet(String str, String separator) {
        String[] values = strToStrArray(str, separator);
        Set<String> result = new LinkedHashSet<String>();
        for (int i = 0; i < values.length; i++) {
            result.add(values[i]);
        }
        return result;
    }

    /**
     * 將一個(gè)數(shù)組 用逗號(hào)分隔變?yōu)橐粋€(gè)字符串
     * @param array
     * @return
     */
    public static String ArrayToStr(Object[] array) {
        if (array == null || array.length < 0) {
            return null;
        }
        StringBuffer sb = new StringBuffer();
        for (Object obj : array) {
            if (StringUtils.isNotBlank(obj.toString())) {
                if (sb.length() > 0) {
                    sb.append(DEFAULT_PATH_SEPARATOR);
                }
                sb.append(obj.toString());
            }
        }
        return sb.toString();
    }

    /**
     * CollectionToStr
     * @param coll
     * @return
     */
    public static String CollectionToStr(Collection<String> coll) {
        StringBuffer sb = new StringBuffer();
        int i = 0;
        for (String string : coll) {
            if (i > 0) {
                sb.append(",");
            }
            i++;
            sb.append(string);
        }
        return sb.toString();
    }

    /**
     * 轉(zhuǎn)換給定字符串的編碼格式
     * @param inputString  待轉(zhuǎn)換字符串對(duì)象
     * @param inencoding 待轉(zhuǎn)換字符串的編碼格式
     * @param outencoding  準(zhǔn)備轉(zhuǎn)換為的編碼格式
     * @return 指定編碼與字符串的字符串對(duì)象
     */
    public static String encodingTransfer(String inputString, String inencoding, String outencoding) {
        if (inputString == null || inputString.length() == 0) {
            return inputString;
        }
        try {
            return new String(inputString.getBytes(outencoding), inencoding);
        } catch (Exception e) {
            return inputString;
        }
    }

    /**
     * 字符串是否為非空白 空白的定義如下： <br>
     * 1、不為null <br>
     * 2飞醉、不為""<br>
     * @param str 被檢測(cè)的字符串
     * @return 是否為非空
     */
    public static boolean isNotEmpty(CharSequence str) {
        return false == isEmpty(str);
    }

    /**
     * 刪除字符串中指定的字符 只要在delStrs參數(shù)中出現(xiàn)的字符冲茸，并且在inputString中也出現(xiàn)都會(huì)將其它刪除
     * @param inputString 待做刪除處理的字符串
     * @param delStrs  作為刪除字符的參照數(shù)據(jù)，用逗號(hào)分隔缅帘。如果要?jiǎng)h除逗號(hào)可以在這個(gè)字符串再加一個(gè)逗號(hào)
     * @return 返回一個(gè)以inputString為基礎(chǔ)不在delStrs出現(xiàn)新字符串
     */
    public static String delString(String inputString, String delStrs) {
        if (inputString == null || inputString.length() == 0) {
            return inputString;
        }
        String[] strs = strToStrArray(delStrs);
        for (int i = 0; i < strs.length; i++) {
            if ("".equals(strs[i])) {
                inputString = inputString.replaceAll(" ", "");
            } else {
                if (strs[i].compareTo("a") >= 0) {
                    inputString = replace(inputString, strs[i], "");
                } else {
                    inputString = inputString.replaceAll("\\" + strs[i], "");
                }
            }
        }
        if (subCount(delStrs, ",") > strs.length) {
            inputString = inputString.replaceAll("\\,", "");
        }
        return inputString;
    }

    /**
     * 去除左邊多余的空格轴术。
     * @param value  待去左邊空格的字符串
     * @return 去掉左邊空格后的字符串
     */
    public static String trimLeft(String value) {
        String result = value;
        if (result == null) {
            return result;
        }
        char[] ch = result.toCharArray();
        int index = -1;
        for (int i = 0; i < ch.length; i++) {
            if (Character.isWhitespace(ch[i])) {
                index = i;
            } else {
                break;
            }
        }
        if (index != -1) {
            result = result.substring(index + 1);
        }
        return result;
    }

    /**
     * 去除右邊多余的空格。
     * @param value 待去右邊空格的字符串
     * @return 去掉右邊空格后的字符串
     */
    public static String trimRight(String value) {
        String result = value;
        if (result == null) {
            return result;
        }
        char[] ch = result.toCharArray();
        int endIndex = -1;
        for (int i = ch.length - 1; i > -1; i--) {
            if (Character.isWhitespace(ch[i])) {
                endIndex = i;
            } else {
                break;
            }
        }
        if (endIndex != -1) {
            result = result.substring(0, endIndex);
        }
        return result;
    }

    /**
     * 判斷一個(gè)字符串中是否包含另一個(gè)字符串
     * @param parentStr  父串
     * @param subStr  子串
     * @return 如果父串包含子串的內(nèi)容返回真钦无，否則返回假
     */
    public static boolean isInclude(String parentStr, String subStr) {
        return parentStr.indexOf(subStr) >= 0;
    }

    /**
     * 判斷一個(gè)字符串中是否包含另一個(gè)字符串?dāng)?shù)組的任何一個(gè)
     * @param parentStr    父串
     * @param subStrs  子串集合(以逗號(hào)分隔的字符串)
     * @return 如果父串包含子串的內(nèi)容返回真逗栽，否則返回假
     */
    public static boolean isIncludes(String parentStr, String subStrs) {
        String[] subStrArray = strToStrArray(subStrs);
        for (int j = 0; j < subStrArray.length; j++) {
            String subStr = subStrArray[j];
            if (isInclude(parentStr, subStr)) {
                return true;
            } else {
                continue;
            }
        }
        return false;
    }

    /**
     * 判斷一個(gè)子字符串在父串中重復(fù)出現(xiàn)的次數(shù)
     * @param parentStr 父串
     * @param subStr  子串
     * @return 子字符串在父字符串中重得出現(xiàn)的次數(shù)
     */
    public static int subCount(String parentStr, String subStr) {
        int count = 0;

        for (int i = 0; i < ( parentStr.length() - subStr.length() ); i++) {
            String tempString = parentStr.substring(i, i + subStr.length());
            if (subStr.equals(tempString)) {
                count++;
            }
        }
        return count;
    }

    /**
     * 得到在字符串中從開(kāi)始字符串到結(jié)止字符串中間的子串
     * @param parentStr 父串
     * @param startStr 開(kāi)始串
     * @param endStr 結(jié)止串
     * @return 返回開(kāi)始串與結(jié)止串之間的子串
     */
    public static String subString(String parentStr, String startStr, String endStr) {
        return parentStr.substring(parentStr.indexOf(startStr) + startStr.length(), parentStr.indexOf(endStr));
    }

    /**
     * 得到在字符串中從開(kāi)始字符串到結(jié)止字符串中間的子串的集合
     * @param parentStr  父串
     * @param startStr 開(kāi)始串
     * @param endStr 結(jié)止串
     * @return 返回開(kāi)始串與結(jié)止串之間的子串的集合
     */
    public static List<String> subStringList(String parentStr, String startStr, String endStr) {
        List<String> result = new ArrayList<String>();
        List<String> elements = dividToList(parentStr, startStr, endStr);
        for (String element : elements) {
            if (!isIncludes(element, startStr) || !isIncludes(element, endStr)) {
                continue;
            }
            result.add(subString(element, startStr, endStr));
        }
        return result;

    }

    /**
     * 將指定的String轉(zhuǎn)換為Unicode的等價(jià)值
     * 基礎(chǔ)知識(shí)： 所有的轉(zhuǎn)義字符都是由 '\' 打頭的第二個(gè)字符 0-9 :八進(jìn)制 u :是Unicode轉(zhuǎn)意，長(zhǎng)度固定為6位 Other:則為以下字母中的一個(gè) b,t,n,f,r,",\ 都不滿足铃诬，則產(chǎn)生一個(gè)編譯錯(cuò)誤
     * 提供八進(jìn)制也是為了和C語(yǔ)言兼容. b,t,n,f,r 則是為控制字符.書(shū)上的意思為:描述數(shù)據(jù)流的發(fā)送者希望那些信息如何被格式化或者被表示. 它可以寫(xiě)在代碼的任意位置祭陷，只要轉(zhuǎn)義后是合法的. 例如: int c=0\u003b
     * 上面的代碼可以編譯通過(guò)，等同于int c=0; \u003b也就是';'的Unicode代碼
     * @param inStr 待轉(zhuǎn)換為Unicode的等價(jià)字符串
     * @return Unicode的字符串
     */
    public static String getUnicodeStr(String inStr) {
        char[] myBuffer = inStr.toCharArray();
        StringBuffer sb = new StringBuffer();

        for (int i = 0; i < inStr.length(); i++) {
            byte b = (byte) myBuffer[i];
            short s = (short) myBuffer[i];
            String hexS = Integer.toHexString(s);
            sb.append(" \\u");
            sb.append(fillStr(hexS, "0", 4, AFTER));
        }
        return sb.toString();

    }

    /**
     * 判斷一個(gè)字符串是否是合法的Java標(biāo)識(shí)符
     * @param s 待判斷的字符串
     * @return 如果參數(shù)s是一個(gè)合法的Java標(biāo)識(shí)符返回真趣席，否則返回假
     */
    public static boolean isJavaIdentifier(String s) {
        if (s.length() == 0 || Character.isJavaIdentifierStart(s.charAt(0))) {
            return false;
        }
        for (int i = 0; i < s.length(); i++) {
            if (!Character.isJavaIdentifierPart(s.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /**
     * 替換字符串中滿足條件的字符 例如: replaceAll("\com\google\platform\base\\util",'\\','/'); 返回的結(jié)果為: /com/google/platform/base/util
     * @param str 待替換的字符串
     * @param oldchar   待替換的字符
     * @param newchar 替換為的字符
     * @return 將str中的所有oldchar字符全部替換為newchar,并返回這個(gè)替換后的字符串
     */
    public static String replaceAll(String str, char oldchar, char newchar) {
        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if (chars[i] == oldchar) {
                chars[i] = newchar;
            }
        }
        return new String(chars);
    }

    /**
     * 如果inStr字符串與沒(méi)有給定length的長(zhǎng)度兵志，則用fill填充，在指定direction的方向 如果inStr字符串長(zhǎng)度大于length就直截返回inStr宣肚，不做處理
     * @param inStr
     *            待處理的字符串
     * @param fill
     *            以該字符串作為填充字符串
     * @param length
     *            填充后要求的長(zhǎng)度
     * @param direction
     *            填充方向想罕，如果是AFTER填充在后面，否則填充在前面
     * @return 返回一個(gè)指定長(zhǎng)度填充后的字符串
     */
    public static String fillStr(String inStr, String fill, int length, int direction) {
        if (inStr == null || inStr.length() > length || inStr.length() == 0) {
            return inStr;
        }
        StringBuffer tempStr = new StringBuffer("");
        for (int i = 0; i < length - inStr.length(); i++) {
            tempStr.append(fill);
        }
        if (direction == AFTER) {
            return new String(tempStr.toString() + inStr);
        } else {
            return new String(inStr + tempStr.toString());
        }
    }

    /**
     * 字符串替換
     * @param str
     *            源字符串
     * @param pattern
     *            待替換的字符串
     * @param replace
     *            替換為的字符串
     * @return
     */
    public static String replace(String str, String pattern, String replace) {
        int s = 0;
        int e = 0;
        StringBuffer result = new StringBuffer();
        while ( ( e = str.indexOf(pattern, s) ) >= 0) {
            result.append(str.substring(s, e));
            result.append(replace);
            s = e + pattern.length();
        }
        result.append(str.substring(s));
        return result.toString();
    }

    /**
     * 分隔字符串到一個(gè)集合
     * @param str
     * @param start
     * @param end
     * @return
     */
    public static List<String> dividToList(String str, String start, String end) {
        if (str == null || str.length() == 0) {
            return null;
        }
        int s = 0;
        int e = 0;
        List<String> result = new ArrayList<String>();
        if (isInclude(str, start) && isInclude(str, end)) {
            while ( ( e = str.indexOf(start, s) ) >= 0) {
                result.add(str.substring(s, e));
                s = str.indexOf(end, e) + end.length();
                result.add(str.substring(e, s));
            }
            if (s < str.length()) {
                result.add(str.substring(s));
            }
            if (s == 0) {
                result.add(str);
            }
        } else {
            result.add(str);
        }
        return result;
    }

    /**
     * 首字母大寫(xiě)
     * @param string
     * @return
     */
    public static String upperFrist(String string) {
        if (string == null) {
            return null;
        }
        String upper = string.toUpperCase();
        return upper.substring(0, 1) + string.substring(1);
    }

    /**
     * 首字母小寫(xiě)
     * @param string
     * @return
     */
    public static String lowerFrist(String string) {
        if (string == null) {
            return null;
        }
        String lower = string.toLowerCase();
        return lower.substring(0, 1) + string.substring(1);
    }

    /**
     * URLEncode
     * @param string
     * @param encode
     * @return
     */
    public static String URLEncode(String string, String encode) {
        try {
            return URLEncoder.encode(string, encode);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 將一個(gè)日期類型的對(duì)象，轉(zhuǎn)換為指定格式的字符串
     * 
     * @param date
     *            待轉(zhuǎn)換的日期
     * @param format
     *            轉(zhuǎn)換為字符串的相應(yīng)格式 例如：DateToStr(new Date() ,"yyyy.MM.dd G 'at' hh:mm:ss a zzz");
     * @return 一個(gè)字符串
     *         <p>
     **/
    public static String DateToStr(Date date, String format) {
        SimpleDateFormat formatter = new SimpleDateFormat(format);
        return formatter.format(date);
    }

    /**
     * 對(duì)給定的字符串做html轉(zhuǎn)義
     * 
     * @param string
     * @return
     */
    public static String escapeHtml(String string) {
        if (string == null || string.length() == 0) {
            return "";
        }

        char b;
        char c = 0;
        int i;
        int len = string.length();
        StringBuffer sb = new StringBuffer(len + 4);
        String t;

        for (i = 0; i < len; i += 1) {
            b = c;
            c = string.charAt(i);
            switch (c) {
            case '\\':
            case '"':
                sb.append('\\');
                sb.append(c);
                break;
            case '/':
                if (b == '<') {
                    sb.append('\\');
                }
                sb.append(c);
                break;
            case '\b':
                sb.append("\\b");
                break;
            case '\t':
                sb.append("\\t");
                break;
            case '\n':
                sb.append("\\n");
                break;
            case '\f':
                sb.append("\\f");
                break;
            case '\r':
                sb.append("\\r");
                break;
            default:
                if (c < ' ' || ( c >= '\u0080' && c < '\u00a0' ) || ( c >= '\u2000' && c < '\u2100' )) {
                    t = "000" + Integer.toHexString(c);
                    sb.append("\\u" + t.substring(t.length() - 4));
                } else {
                    sb.append(c);
                }
            }
        }

        return sb.toString();
    }

    /**
     * 生成一個(gè)指定長(zhǎng)度的隨機(jī)字符串
     * @param length
     *            返回的字符串長(zhǎng)度
     * @return 返回一個(gè)隨機(jī)
     */
    public static String randomString(int length) {
        if (length < 1) {
            return null;
        }
        Random randGen = new Random();
        char[] numbersAndLetters = ( "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ).toCharArray();
        char[] randBuffer = new char[length];
        for (int i = 0; i < randBuffer.length; i++) {
            randBuffer[i] = numbersAndLetters[randGen.nextInt(51)];
        }
        return new String(randBuffer);
    }

    /**
     * trim
     * @param target
     * @return
     */
    public final static String trim(String target) {
        if (target == null) {
            return null;
        }

        target = target.trim();

        return "".equals(target) ? null : target;
    }

    /**
     * string to int
     * @param numStr
     * @return
     */
    public static int strToInt(String numStr) {
        try {
            if (isNullOrBlank(numStr)) {
                return 0;
            }
            return Integer.valueOf(numStr);
        } catch (Exception e) {
            logger.error("str2int failed:", e);
        }
        return 0;
    }

    /**
     * 判斷null 或 空字符串
     * @param str
     * @return
     */
    public static boolean isNullOrBlank(String str) {
        if (str == null) {
            return true;
        }
        str = str.trim();
        if (!"".equals(str)) {
            return false;
        } else {
            return true;
        }
    }

    /**
     * 判斷 空字符串
     * @param value
     * @return
     */
    public static boolean isBlank(String value) {
        boolean ret = false;
        if ( ( value != null ) && ("".equals(value))) {
            ret = true;
        }
        return ret;
    }

    /**
     * 判斷null
     */
    public static boolean isNull(Object value) {
        return ( value == null );
    }

    /**
     * Title : 獲取隨機(jī)數(shù)
     * @param digits
     *            隨機(jī)數(shù)取值范圍 默認(rèn)為0123456789
     * @param length
     *            隨機(jī)數(shù)位數(shù) 默認(rèn)為1位
     * @return
     */
    public static String getRandom(String digits, int length) {
        if (null == digits) {
            digits = "0123456789";
        }
        if (length <= 0) {
            length = 1;
        }
        char[] code = new char[length];
        String temp = "";
        for (int i = 0; i < length; i++) {
            code[i] = digits.charAt((int) ( Math.random() * digits.length() ));
            temp += "0";
        }
        String verifyCode = new String(code);

        if (verifyCode.equals(temp)) {
            verifyCode = getRandom(digits, length);
        }
        return verifyCode;
    }

    /**
     * Title : 獲取范圍在min到max間的隨機(jī)數(shù)
     * @author : 聶水根
     * @param min
     * @param max
     * @return
     */
    public static int getRandom(int min, int max) {
        return (int) ( Math.random() * ( max - min ) + min );
    }

    /**
     * Title : 獲取范圍在min到max間的num個(gè)隨機(jī)數(shù)
     * @author : 聶水根
     * @param min
     * @param max
     * @return
     */
    public static Integer[] getRandomNum(int min, int max, int num) {
        Integer[] result = new Integer[num];
        for (int i = 0; i < num; i++) {
            result[i] = getRandom(min, max);
        }
        for (int i = 0; i < num; i++) {
            for (int k = i + 1; k < num; k++) {
                if (result[i].equals(result[k])) {
                    getRandomNum(min, max, num);
                }
            }
        }
        return result;
    }

    /**
     * ifBlank
     * @param ss
     * @return
     */
    public static String ifBlank(String... ss) {
        String ret = "";
        for (String s : ss) {
            if (StringUtils.isNotBlank(s)) {
                ret = s;
                break;
            }
        }
        return ret;
    }

    /**
     * getUrlParamters
     * @param url
     * @param prefix
     * @return
     */
    public static String getUrlParamters(String url, String prefix) {
        String _return = null;
        if (url.indexOf("?") >= 0) {
            url = url.substring(url.indexOf("?") + 1);
            String[] paramters = url.split("&");
            if (paramters != null) {
                for (String s : paramters) {
                    if (s.startsWith(prefix)) {
                        String[] _temp = s.split("=");
                        if (_temp.length > 1) {
                            _return = _temp[1];
                        }
                    }
                }
            }
        }
        return _return;

    }

    /**
     * 字符串轉(zhuǎn)換成Long型數(shù)字
     * @param src
     * @return
     */
    public static long toLong(String src) {
        long dest = 0;
        if (src == null || "".equals(src.trim())) {
            return 0;
        }
        try {
            dest = Long.parseLong(src.trim());
        } catch (Exception e) {
        }
        return dest;
    }

    /**
     * 創(chuàng)建*Info類型的字符串按价，一般用于信息查詢類接口的返回惭适。
     * 例如，調(diào)用buildInfoString("#",aaa,bbb,null,ddd); 得到字符串：aaa#bbb##ddd
     * @param delimiter
     * @param items
     * @return
     */
    public static String buildInfoString(String delimiter, Object... items) {
        StringBuffer buff = new StringBuffer();
        boolean firstItem = true;
        for (Object item : items) {
            if (firstItem) {
                firstItem = false;
            } else {
                buff.append(delimiter);
            }

            if (item == null) {
                buff.append("");
            } else {
                buff.append(item.toString());
            }
        }
        return buff.toString();
    }

    /**
     * yuan2Cent
     * @param src
     * @return
     */
    public static long yuan2Cent(String src) {
        if (src == null || "".equals(src.trim())) {
            return 0;
        }
        long ret = 0;
        try {
            ret = (long) ( Math.round(Double.parseDouble(src) * 100) );
        } catch (Exception e) {
        }
        return ret;
    }

    /**
     * 把分轉(zhuǎn)換為元
     * @param src
     * @param floor
     *            是否取整
     * @return
     */
    public static String cent2Yuan(String src, boolean floor) {

        long temp = 0;
        try {
            String tem = src.trim();
            temp = Long.parseLong(tem);
        } catch (Exception e) {
        }
        return cent2Yuan(temp, floor);
    }

    /**
     * cent2Yuan
     * @param src
     * @param floor
     * @return
     */
    public static String cent2Yuan(long src, boolean floor) {
        DecimalFormat SDF_YUAN = new DecimalFormat("0.00");
        String yuan = "0.00";
        try {
            yuan = SDF_YUAN.format(src / 100.00);
        } catch (Exception e) {
        }
        if (floor) {
            int idxDot = yuan.indexOf(".");
            if (idxDot >= 0) {
                yuan = yuan.substring(0, idxDot);
            }
        }
        return yuan;

    }

    /**
     * cent2Yuan
     * @param src
     * @param floor
     * @return
     */
    public static String cent2Yuan(Double src, boolean floor) {
        DecimalFormat SDF_YUAN = new DecimalFormat("0.00");
        String yuan = "0.00";
        try {
            yuan = SDF_YUAN.format(src / 100.00);
        } catch (Exception e) {
        }
        if (floor) {
            int idxDot = yuan.indexOf(".");
            if (idxDot >= 0) {
                yuan = yuan.substring(0, idxDot);
            }
        }
        return yuan;

    }

    /**
     * 
     * 將一個(gè)字符串按分隔符分成多個(gè)子串楼镐。 此方法用于代替Jdk的String.split()方法癞志，不同的地方：<br>
     * (1)在此方法中，空字符串不管在哪個(gè)位置都視為一個(gè)有效字串框产。 <br>
     * (2)在此方法中凄杯，分隔符參數(shù)不是一個(gè)正則表達(dá)式。<br>
     * 
     * @param src
     *            源字符串
     * @param delimiter
     *            分隔符
     * @return 字符串?dāng)?shù)組秉宿。
     */
    public static String[] split(String src, String delimiter) {
        if (src == null || delimiter == null || "".equals(src.trim()) || "".equals(delimiter)) {
            return new String[] { src };
        }
        ArrayList<String> list = new ArrayList<String>();
        int lengthOfDelimiter = delimiter.length();
        int pos = 0;
        while (true) {
            if (pos < src.length()) {

                int indexOfDelimiter = src.indexOf(delimiter, pos);
                if (indexOfDelimiter < 0) {
                    list.add(src.substring(pos));
                    break;
                } else {
                    list.add(src.substring(pos, indexOfDelimiter));
                    pos = indexOfDelimiter + lengthOfDelimiter;
                }
            } else if (pos == src.length()) {
                list.add("");
                break;
            } else {
                break;
            }
        }
        String[] result = new String[list.size()];
        list.toArray(result);
        return result;
    }

    /**
     * 若原對(duì)象為Null則返回空字符串,否則先轉(zhuǎn)為String類型戒突，再剪去字符串兩端的空格及控制字符
     * 
     * @param src
     * @return
     */
    public static String trim(Object src) {
        if (src == null) {
            return "";
        }
        String str = src.toString();
        return str.trim();
    }

    /**
     * 將一個(gè)形如key1=value1&key2=value2...的字符串轉(zhuǎn)換成Map映射。
     * @param src
     * @return
     * 
     */
    public static Map<String, String> string2Map(String src) {
        return string2Map(src, String.class, String.class, "&", "=");
    }

    /**
     * 將一個(gè)形如key1=value1&key2=value2...的字符串轉(zhuǎn)換成Map映射描睦。 注意：key和value只支持類型為String,Long,Integer,Float,Double膊存！
     * @param <K>
     * @param <V>
     * @param src
     *            源字符串
     * @param keyClass
     *            生成的Map的Key的類型，默認(rèn)String
     * @param valueClass
     *            生成的Map的Value的類型忱叭，默認(rèn)String
     * @param fieldDelimiter
     *            字段與字段之間的分隔符隔崎，默認(rèn)&
     * @param keyValueDelimiter
     *            key和value之間的分隔符，默認(rèn)=
     * @return
     * 
     */
    public static <K extends Object, V extends Object> Map<K, V> string2Map(String src, Class<K> keyClass, Class<V> valueClass,
            String fieldDelimiter, String keyValueDelimiter) {
        Map<K, V> result = new HashMap<K, V>();

        if (src == null || "".equals(src.trim())) {
            return result;
        }

        String[] fields = StringHelper.split(src, fieldDelimiter);
        for (int i = 0; i < fields.length; i++) {
            String[] keyValue = StringHelper.split(fields[i], keyValueDelimiter);
            String key = keyValue[0];
            String value = keyValue[1];

            K objKey = null;
            V objValue = null;

            if (keyClass == String.class) {
                objKey = (K) key;
            } else if (keyClass == Integer.class) {
                objKey = (K) Integer.valueOf(key);
            } else if (keyClass == Long.class) {
                objKey = (K) Long.valueOf(key);
            } else if (keyClass == Float.class) {
                objKey = (K) Float.valueOf(key);
            } else if (keyClass == Double.class) {
                objKey = (K) Double.valueOf(key);
            } else {
                return null;
            }

            if (valueClass == String.class) {
                objValue = (V) value;
            } else if (valueClass == Integer.class) {
                objValue = (V) Integer.valueOf(value);
            } else if (valueClass == Long.class) {
                objValue = (V) Long.valueOf(value);
            } else if (valueClass == Float.class) {
                objValue = (V) Float.valueOf(value);
            } else if (valueClass == Double.class) {
                objValue = (V) Double.valueOf(value);
            } else {
                return null;
            }

            result.put(objKey, objValue);

        }

        return result;
    }

    /**
     * Map轉(zhuǎn)換成字符串.主要用于打印調(diào)試信息
     * @param map
     * @return
     */
    public static String map2String(Map map) {
        return map2String(map, "", "", "", true, "=");
    }

    /**
     * Map轉(zhuǎn)換成字符串窑多，主要用于打印調(diào)試信息
     * @param map
     * @param head
     *            輸出的頭
     * @param entryPrefix
     *            每一項(xiàng)輸出的前綴
     * @param foot
     *            輸出的腳
     * @param isOneItemPl
     *            是否每行一項(xiàng)
     * @param kvSep
     *            Key和Value的分隔符
     * @return
     */
    public static String map2String(Map map, String head, String entryPrefix, String foot, boolean isOneItemPl, String kvSep) {

        if (map == null) {
            return null;
        }
        String lineSeparator = (String) System.getProperty("line.separator");
        StringBuffer buff = new StringBuffer();
        if (head != null && !"".equals(head)) {
            buff.append(head);

            if (isOneItemPl) {
                buff.append(lineSeparator);
            }
        }
        if (entryPrefix == null) {
            entryPrefix = "";
        }
        for (Iterator iterator = map.entrySet().iterator(); iterator.hasNext();) {
            Entry entry = (Entry) iterator.next();
            buff.append(entryPrefix).append(entry.getKey()).append(kvSep).append(StringHelper.ArrayToStr((Object[]) entry.getValue()));

            if (isOneItemPl) {
                buff.append(lineSeparator);
            }
        }
        if (foot != null && !"".equals(foot)) {
            buff.append(foot);
            if (isOneItemPl) {
                buff.append(lineSeparator);
            }
        }
        return buff.toString();
    }

    /**
     * 填充數(shù)字0
     * @param src
     * @param targetLength
     * @return
     */
    public static String fill(long src, int targetLength) {
        return fill(String.valueOf(src), "0", targetLength, true);
    }

    /**
     * 填充字符串仍稀。如果原字符串比目標(biāo)長(zhǎng)度長(zhǎng)，則截去多出的部分埂息。如果onTheLeft等于true 截去左邊部分技潘，否則截去右邊部分。 注意填充物一般為單個(gè)字符，如果是多個(gè)字符，可能導(dǎo)致最后的結(jié)果不可用毅否。
     * @param src
     *            原字符串
     * @param padding
     *            填充物聋亡，一般是0迅细、空格等
     * @param targetLength
     *            目標(biāo)長(zhǎng)度
     * @param onTheLeft
     *            是否左填充。
     * @return
     */
    public static String fill(String src, String padding, int targetLength, boolean onTheLeft) {

        if (src == null) {
            src = "";
        }
        while (src.length() < targetLength) {
            if (onTheLeft) {
                src = padding + src;
            } else {
                src = src + padding;
            }
        }
        if (src.length() > targetLength) {
            if (onTheLeft) {
                src = src.substring(src.length() - targetLength);
            } else {
                src = src.substring(0, targetLength);
            }
        }
        return src;
    }

    /**
     * changeListToString
     * @param source
     * @param delimiter
     * @return
     */
    public static String changeListToString(List<String> source, String delimiter) {
        StringBuilder builder = new StringBuilder();
        if (source != null && source.size() > 0) {
            int len = source.size();
            for (int i = 0; i < len; i++) {
                builder.append(source.get(i));
                if (i < len - 1) {
                    builder.append(delimiter);
                }

            }
        }
        return builder.toString();
    }

    /**
     * changeListToStringWithTag
     * @param source
     * @param delimiter
     * @param tag
     * @return
     */
    public static String changeListToStringWithTag(List<String> source, String delimiter, String tag) {
        StringBuilder builder = new StringBuilder();
        if (source != null && source.size() > 0) {
            int len = source.size();
            for (int i = 0; i < len; i++) {
                builder.append(tag + source.get(i) + tag);
                if (i < len - 1) {
                    builder.append(delimiter);
                }

            }
        }
        return builder.toString();
    }

    /**
     * 是否存在null、或者空字符串。任意一個(gè)參數(shù)滿足條件奔坟，返回true；否則返回false搭盾。<br>
     * 先將參數(shù)對(duì)象轉(zhuǎn)成字符串咳秉，修剪后進(jìn)行判斷。僅包含空格或ASCII控制字符也視為條件滿足鸯隅。<br>
     * Noe:Null Or Empty<br>
     * @param someObj
     * @return
     */
    public static boolean existNoe(Object... someObj) {
        if (someObj == null || someObj.length == 0) {
            throw new RuntimeException("參數(shù)不能為空,必須有至少一個(gè)對(duì)象");
        }
        for (int i = 0; i < someObj.length; i++) {
            Object obj = someObj[i];
            if (obj == null || "".equals(obj.toString().trim())) {
                return true;
            }
        }
        return false;

    }

    /**
     * 若原字符串為Null則返回空字符串澜建。
     * @param src
     * @return
     */
    public static String null2Empty(String src) {
        if (src == null) {
            return "";
        }
        return src;
    }

    /**
     * 若原字符串為Null則返回空字符串。
     * 
     * @param src
     * @return
     */
    public static boolean isEmpty(String src) {
        String value = null2Empty(src);
        if ("".equals(value)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 是否全部非空
     * @param src
     * @return
     */
    public static boolean isAllNotEmpty(String... src) {
        for (int i = 0; i < src.length; i++) {
            String value = src[i];
            if (value == null || "".equals(value)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 是否全部為空
     * @param src
     * @return
     */
    public static boolean isAllEmpty(String... src) {
        for (int i = 0; i < src.length; i++) {
            String value = src[i];
            if (value != null && !"".equals(value)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 是否全為字母或數(shù)字
     * @param src
     * @return
     */
    public static boolean isLetterOrNumber(String src) {
        if (src == null) {
            return false;
        }
        try {
            byte[] bytesOfSrc = src.getBytes("utf-8");

            for (int i = 0; i < bytesOfSrc.length; i++) {
                byte one = bytesOfSrc[i];
                if (one < '0' || ( one > '9' && one < 'A' ) || ( one > 'Z' && one < 'a' ) || one > 'z') {
                    return false;
                }
            }
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    /**
     * privacyInfo
     * @param currString
     * @return
     */
    public static String privacyInfo(String currString) {
        String targetString = "";
        if (!StringHelper.isBlank(currString)) {
            if (currString.length() <= 3) {
                targetString = currString.replace(StringUtils.substring(currString, 0, 1), "*");
            } else if (currString.length() > 3) {
                targetString = currString.replace(StringUtils.substring(currString, 0, 2), "*");
            }
        }

        return targetString;
    }

    /**
     * 字符串是否為空，空的定義如下:<br>
     * 1炕舵、為null <br>
     * 2何之、為""<br>
     * @param str 被檢測(cè)的字符串
     * @return 是否為空
     */
    public static boolean isEmpty(CharSequence str) {
        return str == null || str.length() == 0;
    }

    /**
     * 如果對(duì)象是字符串是否為空串空的定義如下:<br>
     * 1、為null <br>
     * 2咽筋、為""<br>
     * @param obj 對(duì)象
     * @return 如果為字符串是否為空串
     */
    public static boolean isEmptyIfStr(Object obj) {
        if (null == obj) {
            return true;
        } else if (obj instanceof CharSequence) {
            return 0 == ((CharSequence) obj).length();
        }
        return false;
    }

    /**
     * 去掉指定后綴
     * @param str 字符串
     * @param suffix 后綴
     * @return 切掉后的字符串溶推，若后綴不是 suffix， 返回原字符串
     */
    public static String removeSuffix(CharSequence str, CharSequence suffix) {
        if (isEmpty(str) || isEmpty(suffix)) {
            return str(str);
        }
        final String str2 = str.toString();
        if (str2.endsWith(suffix.toString())) {
            // 截取前半段
            return subPre(str2, str2.length() - suffix.length());
        }
        return str2;
    }

    /**
     * 切割指定位置之前部分的字符串
     * @param string 字符串
     * @param toIndex 切割到的位置（不包括）
     * @return 切割后的剩余的前半部分字符串
     */
    public static String subPre(CharSequence string, int toIndex) {
        return sub(string, 0, toIndex);
    }


    /**
     * {@link CharSequence} 轉(zhuǎn)為字符串晤硕，null安全
     * @param cs {@link CharSequence}
     * @return 字符串
     */
    public static String str(CharSequence cs) {
        return null == cs ? null : cs.toString();
    }


    /**
     * 改進(jìn)JDK subString<br>
     * index從0開(kāi)始計(jì)算悼潭，最后一個(gè)字符為-1<br>
     * 如果from和to位置一樣庇忌，返回 "" <br>
     * 如果from或to為負(fù)數(shù)舞箍，則按照l(shuí)ength從后向前數(shù)位置，如果絕對(duì)值大于字符串長(zhǎng)度皆疹，則from歸到0疏橄，to歸到length<br>
     * 如果經(jīng)過(guò)修正的index中from大于to，則互換from和to example: <br>
     * abcdefgh 2 3 =》 c <br>
     * abcdefgh 2 -3 =》 cde <br>
     * @param str String
     * @param fromIndex 開(kāi)始的index（包括）
     * @param toIndex 結(jié)束的index（不包括）
     * @return 字串
     */
    public static String sub(CharSequence str, int fromIndex, int toIndex) {
        if (isEmpty(str)) {
            return str(str);
        }
        int len = str.length();

        if (fromIndex < 0) {
            fromIndex = len + fromIndex;
            if (fromIndex < 0) {
                fromIndex = 0;
            }
        } else if (fromIndex > len) {
            fromIndex = len;
        }

        if (toIndex < 0) {
            toIndex = len + toIndex;
            if (toIndex < 0) {
                toIndex = len;
            }
        } else if (toIndex > len) {
            toIndex = len;
        }

        if (toIndex < fromIndex) {
            int tmp = fromIndex;
            fromIndex = toIndex;
            toIndex = tmp;
        }

        if (fromIndex == toIndex) {
            return EMPTY;
        }

        return str.toString().substring(fromIndex, toIndex);
    }


    /**
     * 切割指定位置之后部分的字符串
     *
     * @param string 字符串
     * @param fromIndex 切割開(kāi)始的位置（包括）
     * @return 切割后后剩余的后半部分字符串
     */
    public static String subSuf(CharSequence string, int fromIndex) {
        if (isEmpty(string)) {
            return null;
        }
        return sub(string, fromIndex, string.length());
    }

    /**
     * 比較兩個(gè)字符串是否相等
     * @param one
     * @param another
     * @return
     */
    public static boolean equals(String one, String another) {
        if (one == null) {
            if (another == null) {
                return true;
            } else {
                return false;
            }
        } else {
            if (another == null) {
                return false;
            } else {
                return one.equals(another);
            }
        }
    }
    
    /**
     * 獲取字符串
     * @param value 字符串
     * @param maxLen 最大字符串長(zhǎng)度
     * @return
     */
    public static String getSubStr(String value,int maxLen){
        if (value.length() > maxLen) {
            value = value.substring(0, maxLen);
        }
        return value;
    }

    public static boolean getBoolean(String str) {
        if (isNull(str)) {
            return false;
        } else if ("0".equals(str.trim())) {
            return false;
        } else {
            return "1".equals(str.trim()) || "true".equalsIgnoreCase(str.trim());
        }
    }


    /**
     * @Description: Just for test
     * @Autor:jasonandy@hotmail.com
     */
    public static void main(String[] args) {
        //buildInfoString
        String strKey = buildInfoString("_", "湘A10086", "2019-01-01", "10010");
        System.out.println(strKey);
        System.out.println(getUnicodeStr(strKey));
        //System.out.println(getDelRepeStrKey("湘A10086","2019-01-01","10010"));
    }
}