JAVA常用的字符串操作

public class StringUtil {

    /**
     * 私有构造方法，防止类的实例化，因为工具类不需要实例化。
     */
    private StringUtil() {
    }

    private static final char[] digits = {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
        'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
        'U', 'V', 'W', 'X', 'Y', 'Z'};

    /**
     * 判断String是否为空
     *
     * @param str
     * @return
     */
    public static boolean isNull(String str) {
        return (str == null || str.length() == 0);
    }

    /**
     * 判断String是否非空
     *
     * @param str
     * @return
     */
    public static boolean isNotNull(String str) {
        return !isNull(str);
    }

    /**
     * 判断两个String是否相等。忽略大小写。
     *
     * @param str1
     * @param str2
     * @return
     */
    public static boolean isEquals(String str1, String str2) {
        return str1.equalsIgnoreCase(str2);
    }

    /**
     * 替换mainStrin中的所有oldString为newString，并返回替换后的String
     *
     * @param mainString 需要替换其中的某个子串的String
     * @param oldString  mainString中的要替换的String
     * @param newString  替换oldString的String
     * @return newString替换mainString中的oldString后的新String
     */
    public static String replace(String mainString, String oldString,
                                 String newString) {
        if (mainString == null) {
            return null;
        }
        if (oldString == null || oldString.length() == 0) {
            return mainString;
        }
        if (newString == null) {
            newString = "";
        }

        int i = mainString.lastIndexOf(oldString);

        if (i < 0) {
            return mainString;
        }

        StringBuffer mainSb = new StringBuffer(mainString);

        while (i >= 0) {
            mainSb.replace(i, i + oldString.length(), newString);
            i = mainString.lastIndexOf(oldString, i - 1);
        }
        return mainSb.toString();
    }

    /**
     * @param mainString
     * @param oldString
     * @param newString
     * @return
     */
    public static String replaceFirst(String mainString, String oldString,
                                      String newString) {
        if (mainString == null) {
            return null;
        }
        if (oldString == null || oldString.length() == 0) {
            return mainString;
        }
        if (newString == null) {
            newString = "";
        }

        int i = mainString.lastIndexOf(oldString);

        if (i < 0) {
            return mainString;
        }

        StringBuffer mainSb = new StringBuffer(mainString);

        if (i >= 0) {
            mainSb.replace(i, i + oldString.length(), newString);
        }
        return mainSb.toString();
    }

    /**
     * 连接List中的所有元素以创建一个String，其中List中的元素间以指定的delim来分隔
     *
     * @param list  需要连接的String为元素的List
     * @param delim List中的元素的分隔符。(null表示直接连接list中的元素，不加入分割符)
     * @return String 形式为：list的元素＋delim＋list的元素＋delim＋...
     */
    public static String join(List list, String delim) {
        if (list == null || list.size() < 1) {
            return null;
        }
        StringBuffer buf = new StringBuffer();
        Iterator i = list.iterator();

        while (i.hasNext()) {
            buf.append((String) i.next());
            if (i.hasNext()) {
                buf.append(delim);
            }
        }
        return buf.toString();
    }

    /**
     * 将字符串数组使用指定的分隔符合并成一个字符串。
     *
     * @param array 字符串数组
     * @param delim 分隔符，为null的时候使用""作为分隔符（即没有分隔符）
     * @return 合并后的字符串
     */
    public static String join(String[] array, String delim) {
        int length = array.length - 1;
        if (delim == null) {
            delim = "";
        }
        StringBuffer result = new StringBuffer(length * 8);
        for (int i = 0; i < length; i++) {
            result.append(array[i]);
            result.append(delim);
        }
        result.append(array[length]);
        return result.toString();
    }

    /**
     * 以指定的delim分隔符分隔String，并将分隔的每一个String作为List的一个元素。
     *
     * @param str   需要分隔的string
     * @param delim 分隔String的符合 (null表示以空格作为分隔符)
     * @return 存储了分隔的子串的List
     */
    public static List splitList(String str, String delim) {
        List splitList = null;
        StringTokenizer st = null;

        if (str == null) {
            return splitList;
        }

        if (delim != null) {
            st = new StringTokenizer(str, delim);
        } else {
            st = new StringTokenizer(str);
        }
        if (st != null && st.hasMoreTokens()) {
            splitList = new ArrayList();

            while (st.hasMoreTokens()) {
                splitList.add(st.nextToken());
            }
        }
        return splitList;
    }

    /**
     * 此方法将给出的字符串source使用delim划分为单词数组。
     *
     * @param source 需要进行划分的原字符串
     * @param delim  单词的分隔字符串
     * @return 划分以后的数组，如果source为null的时候返回以source为唯一元素的数组，
     *         如果delim为null则使用逗号作为分隔字符串。
     */
    public static String[] split(String source, String delim) {
        String[] wordLists;
        if (source == null) {
            wordLists = new String[1];
            wordLists[0] = source;
            return wordLists;
        }
        if (delim == null) {
            delim = ",";
        }
        StringTokenizer st = new StringTokenizer(source, delim);
        int total = st.countTokens();
        wordLists = new String[total];
        for (int i = 0; i < total; i++) {
            wordLists[i] = st.nextToken();
        }
        return wordLists;
    }

    /**
     * 此方法将给出的字符串source使用delim划分为单词数组。
     *
     * @param source 需要进行划分的原字符串
     * @param delim  单词的分隔字符
     * @return 划分以后的数组，如果source为null的时候返回以source为唯一元素的数组。
     */
    public static String[] split(String source, char delim) {
        return split(source, String.valueOf(delim));
    }

    /**
     * 此方法将给出的字符串source使用逗号划分为单词数组。
     *
     * @param source 需要进行划分的原字符串
     * @return 划分以后的数组，如果source为null的时候返回以source为唯一元素的数组。
     */
    public static String[] split(String source) {
        return split(source, ",");
    }

    /**
     * 转换成sql中IN类型的字符串
     * 如: aaa,bbb,ccc,ddd,de
     * 转换结果为：'aaa','bbb','ccc','ddd','de'
     *
     * @param source
     * @param delim
     * @return
     */
    public static String ChangeToInsqlType(String source, String delim) {
        String s = "";
        String[] l = split(source, delim);
        for (int k = 0; k < l.length; k++) {
            s += "'" + l[k] + "'";
            if (k != l.length - 1) s += ",";
        }
        return s;
    }

    /**
     * 从存储了name/value对的String中得到Map。并对其中的name和value进行Html的编码。
     *
     * @param str 转换为Map的String，String的形式为：name1=value1?name2=value2?...
     * @return a Map 存储了name/value对
     */
    public static Map strToMap(String str) {
        if (str == null) {
            return null;
        }
        Map decodedMap = new HashMap();
        List elements = splitList(str, "?");
        Iterator i = elements.iterator();

        while (i.hasNext()) {
            String s = (String) i.next();
            List e = splitList(s, "=");
            if (e.size() != 2) {
                continue;
            }
            String name = (String) e.get(0);
            String value = (String) e.get(1);

            decodedMap.put(URLDecoder.decode(name), URLDecoder.decode(value));
        }
        return decodedMap;
    }

    /**
     * 从Map中得到经过Html格式编码的String。注意：map的元素必须都是String。
     *
     * @param map 存储name/value对的Map
     * @return String 经过Html格式编码的String：name1=value1?name2=value2?...
     */
    public static String mapToStr(Map map) {
        if (map == null) {
            return null;
        }
        StringBuffer buf = new StringBuffer();
        Set keySet = map.keySet();
        Iterator i = keySet.iterator();
        boolean first = true;

        while (i.hasNext()) {
            Object key = i.next();
            Object value = map.get(key);

            if (!(key instanceof String) || !(value instanceof String)) {
                continue;
            }
            String encodedName = URLEncoder.encode((String) key);
            String encodedValue = URLEncoder.encode((String) value);

            if (first) {
                first = false;
            } else {
                buf.append("?");
            }
            buf.append(encodedName);
            buf.append("=");
            buf.append(encodedValue);
        }
        return buf.toString();
    }

    /**
     * 删除String中的所有空格，并返回删除后的String
     *
     * @param str 需要进行删除操作的String
     * @return String 删除空格后的String
     */
    public static String removeSpaces(String str) {
        StringBuffer newString = new StringBuffer();
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) != ' ') {
                newString.append(str.charAt(i));
            }
        }
        return newString.toString();
    }

    /**
     * 判断一个String里是不是包含另一个String
     *
     * @param MainString
     * @param containedString
     * @return
     */
    public static boolean contains(String MainString, String containedString) {
        int i = MainString.indexOf(containedString);
        if (i == -1) {
            return false;
        } else {
            return true;
        }
    }

    /**
     * 字符串数组中是否包含指定的字符串。
     *
     * @param caseSensitive 是否大小写敏感
     * @return 包含时返回true，否则返回false
     */
    public static int contains(String[] mainStrings, String containedString,
                               boolean caseSensitive) {
        for (int i = 0; i < mainStrings.length; i++) {
            if (caseSensitive == true) {
                if (mainStrings[i].equals(containedString)) {
                    return i;
                }
            } else {
                if (mainStrings[i].equalsIgnoreCase(containedString)) {
                    return i;
                }
            }
        }
        return -1;
    }

    /**
     * 切取字符串
     *
     * @param srcString
     * @param key
     * @param length
     * @return
     */
    public static String getString(String srcString, String key, int length, String postfix) {
        if (srcString == null || srcString.trim().length() == 0) return "";
        String returnStr = "";
        int index = srcString.indexOf(key);
        if (index > 0) {
            returnStr = srcString.substring(0, index) + postfix;
        } else {
            if (srcString.length() > length) {
                returnStr = srcString.substring(0, length) + postfix;
            } else {
                returnStr = srcString;
            }
        }
        returnStr = returnStr.replaceAll("<P>", "");
        returnStr = returnStr.replaceAll("<p>", "");
        returnStr = returnStr.replaceAll("</P>", "");
        returnStr = returnStr.replaceAll("</p>", "");
        returnStr = returnStr.replaceAll("<BR>", "");
        returnStr = returnStr.replaceAll("<br>", "");
        return returnStr;
    }

    /**
     * 字符串数组中是否包含指定的字符串。大小写敏感。
     *
     * @return 包含时返回true，否则返回false
     */
    public static int contains(String[] mainStrings, String containedString) {
        return contains(mainStrings, containedString, true);
    }

    /**
     * 不区分大小写判定字符串数组中是否包含指定的字符串。
     *
     * @return 包含时返回true，否则返回false
     */
    public static int containsIgnoreCase(String[] mainStrings,
                                         String containedString) {
        return contains(mainStrings, containedString, false);
    }

    /**
     * 产生制定长度的随机字符串.
     * <p>所产生的字符串包括从0到九这些数字及26个大写英文字母.
     *
     * @param length 所需字符串的长度，整数。
     * @return 字符串
     */
    public static String getRandomString(int length) {
        int temp;
        String strRnd = "";
        for (int i = 0; i < length; i++) {
            temp = (new Double(Math.random() * 997))
                    .intValue() % digits.length;
            strRnd += String.valueOf(digits[temp]);
        }
        return strRnd;
    }

    /**
     * 将一个字符串进行中文处理.
     * <p>解决由编码原因产生的中文乱码问题.
     *
     * @param str 输入字符串
     * @return 输出转换后的字符串，如果出错，返回null。
     */
    public static String toChinese(String str) {
        try {
            if (str == null) {
                return null;
            } else {
                str = new String(str.getBytes("ISO8859_1"), "GBK");
                return str;
            }
        } catch (Exception e) {
            System.err.println(e.getMessage());
            return null;
        }
    }

    /**
     * 将一个字符串进行中文处理.
     * <p>解决由编码原因产生的中文乱码问题.
     *
     * @param str 输入字符串
     * @return 输出转换后的字符串，如果出错，返回null。
     */
    public static String toUTF(String str) {
        try {
            if (str == null) {
                return null;
            } else {
                str = new String(str.getBytes("GB2312"), "GB2312");
                return str;
            }
        } catch (Exception e) {
            System.err.println(e.getMessage());
            return null;
        }
    }

    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();
    }

    public static String UnicodeToGB(String strIn) {
        byte[] b;
        String strOut = null;
        if (strIn == null || (strIn.trim()).equals(""))
            return strIn;
        try {
            b = strIn.getBytes("GB2312");
            strOut = new String(b, "ISO8859_1");
        } catch (Exception e) {
            System.out.println("unicodeToGB exception : " + e.getMessage() + "\n");
        }
        return strOut;
    }

    public static String GBToUnicode(String strIn) {
        byte[] b;
        String strOut = null;
        if (strIn == null || (strIn.trim()).equals(""))
            return strIn;
        try {
            b = strIn.getBytes("ISO8859_1");
            strOut = new String(b, "GB2312");
        } catch (Exception e) {
            System.out.println("GBToUnicode exception : " + e.getMessage() + "\n");
        }
        return strOut;
    }

    /**
     * 将一个字符串进行中文处理.
     * <p>解决中文名不能下载的问题.
     *
     * @return 输出转换后的字符串，如果出错，返回null。
     */
    public static String transCode(String value, String enc) {
        try {
            if (value == null) {
                return null;
            } else {
                value = value.trim();
                value = new String(value.getBytes("ISO8859_1"), enc);
                return value;
            }
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 将阿拉伯数字转换为中文大写数字.
     * 注意：该方法为临时使用，对0支持不好.
     * 例如：100将转换为一百零十零.
     *
     * @param number 阿拉伯数字
     * @return 中文大写数字
     */
    public static String toChineseNumber(String number) {
        String[] num = {
            "零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};
        String[] unt = {
            "", "", "十", "百", "千", "万"};
        String value = "";
        for (int i = 0, j = number.length(); i < number.length(); j--, i++) {
            value += num[Integer.parseInt(String.valueOf(number.charAt(i)))] +
                    unt[j];
        }
        value = value + number.substring(number.length());
        if (value.substring(0, 1) == "一" && value.length() == 3) {
            value = value.substring(1, value.length());
        }
        return value;
    }

    /**
     * 将阿拉伯数字转换为中文大写数字
     *
     * @param number 阿拉伯数字
     * @return 中文大写数字
     */
    public static String toChineseNumber(int number) {
        return toChineseNumber(String.valueOf(number));
    }

    /**
     * 循环打印字符串数组。
     * 字符串数组的各元素间以指定字符分隔，
     * 如果字符串中已经包含指定字符则在字符串的两端加上双引号。
     *
     * @param strings 字符串数组
     * @param delim   分隔符
     * @param out     打印到的输出流
     */
    public static void printStrings(String[] strings, String delim,
                                    OutputStream out) {
        try {
            if (strings != null) {
                int length = strings.length - 1;
                for (int i = 0; i < length; i++) {
                    if (strings[i] != null) {
                        if (strings[i].indexOf(delim) > -1) {
                            out.write(("\"" + strings[i] + "\"" + delim).
                                    getBytes());
                        } else {
                            out.write((strings[i] + delim).getBytes());
                        }
                    } else {
                        out.write("null".getBytes());
                    }
                }
                if (strings[length] != null) {
                    if (strings[length].indexOf(delim) > -1) {
                        out.write(("\"" + strings[length] + "\"").getBytes());
                    } else {
                        out.write(strings[length].getBytes());
                    }
                } else {
                    out.write("null".getBytes());
                }
            } else {
                out.write("null".getBytes());
            }
        } catch (IOException e) {

        }
    }

    /**
     * 循环打印字符串数组到标准输出。
     * 字符串数组的各元素间以指定字符分隔，如果字符串中已经包含指定字符则在字符串的两端加上双引号。
     *
     * @param strings 字符串数组
     * @param delim   分隔符
     */
    public static void printStrings(String[] strings, String delim) {
        printStrings(strings, delim, System.out);
    }

    /**
     * 循环打印字符串数组。
     * 字符串数组的各元素间以逗号分隔，如果字符串中已经包含逗号则在字符串的两端加上双引号。
     *
     * @param strings 字符串数组
     * @param out     打印到的输出流
     */
    public static void printStrings(String[] strings, OutputStream out) {
        printStrings(strings, ",", out);
    }

    /**
     * 循环打印字符串数组到系统标准输出流System.out。
     * 字符串数组的各元素间以逗号分隔，如果字符串中已经包含逗号则在字符串的两端加上双引号。
     *
     * @param strings 字符串数组
     */
    public static void printStrings(String[] strings) {
        printStrings(strings, ",", System.out);
    }

    /**
     * (解决了一些空格全角占两位置的问题)
     * 取得显示的字符长度，英文，数字占一个位置，汉字占两个位置
     *
     * @param str
     * @return
     */
    public static int getStringLength(String str) {
        /**       int reInt = 0;
         char[] tempChar = str.toCharArray();
         for (int kk = 0; kk < tempChar.length; kk++) {
         String s1 = str.valueOf(tempChar[kk]);
         byte[] b = s1.getBytes();
         reInt += b.length;
         }
         return reInt;   **/
        return str.length();
    }

    /**
     * 判断是否为NULL
     *
     * @param str
     * @return
     */
    public static String getString(String str) {
        if (str == null)
            return "";
        else
            return str;
    }

    /**
     * 判断是否为NULL
     *
     * @param str
     * @return
     */
    public static String getString(String str, String defValue) {
        if (str == null || "".equals(str) || "null".equals(str) || "NULL".equals(str))
            return defValue;
        else
            return str;
    }

    /**
     * 判断是否为NULL
     *
     * @param str
     * @return
     */
    public static String getString(Object str, String defValue) {
        return getString(String.valueOf(str), defValue);
    }

    /**
     * 取字符串的前toCount个字符
     *
     * @param str
     * @param count1
     * @return
     */
    public static String substring(String str, int count1) {
        int count = count1 / 2;
        /**     int i = 0;
         String s = "";
         if (str == null) return "";
         char[] tempChar = str.toCharArray();
         for (int kk = 0; (kk < tempChar.length && count > i); kk++) {
         String s1 = str.valueOf(tempChar[kk]);
         byte[] b = s1.getBytes();
         i += b.length;
         s += tempChar[kk];
         }
         if (count == i || (count == i - 1)) s += "..";
         return s;      **/
        if (str == null) return "";
        if (str.length() < count)
            return str;
        else
            return str.substring(0, count) + "..";
    }

    /**
     * 将字符串转换为整型数
     *
     * @param str
     * @param defaultValue
     * @return
     */
    public static int getInt(String str, int defaultValue) {
        int returnInt = defaultValue;

        try {
            returnInt = Integer.parseInt(str);
        } catch (Exception e) {
            returnInt = defaultValue;
        }
        return returnInt;
    }

    /**
     * 将字符串转换为整型数
     *
     * @param str
     * @param defaultValue
     * @return
     */
    public static long getLong(String str, long defaultValue) {
        long returnInt = defaultValue;
        try {
            returnInt = Long.parseLong(str);
        } catch (Exception e) {
            returnInt = defaultValue;
        }
        return returnInt;
    }

    /**
     * 将字符串转换为整型数
     *
     * @param str
     * @param defaultValue
     * @return
     */
    public static double getDouble(String str, double defaultValue) {
        double returnInt = defaultValue;
        try {
            returnInt = Double.parseDouble(str);
        } catch (Exception e) {
            returnInt = defaultValue;
        }
        return returnInt;
    }

    /**
     * 判断字符串是否以指定字符串开始，
     *
     * @param sourceString
     * @param keyString
     * @return
     */
    public static boolean isBeginWith(String sourceString, String keyString) {
        int index = sourceString.indexOf(keyString);
        if (index == 0)
            return true;
        else
            return false;
    }

    /**
     * 判断字符串是否以指定字符串结束，
     *
     * @param sourceString
     * @param keyString
     * @return
     */
    public static boolean isEndWith(String sourceString, String keyString) {
        int index = sourceString.lastIndexOf(keyString);
        if (index == sourceString.length() - keyString.length())
            return true;
        else
            return false;
    }

    /**
     * 根据流取得字符串，用于clob
     *
     * @param cl
     * @return
     * @throws HibernateException
     * @throws SQLException
     */
    public static String getClobString(java.sql.Clob cl)
            throws HibernateException, SQLException {
        if (cl == null) return "";
        Reader clobReader = cl.getCharacterStream();
        if (clobReader == null) {
            return null;
        }

        String str = new String();
        BufferedReader bufferedClobReader = new BufferedReader(clobReader);
        try {
            String line = null;
            while ((line = bufferedClobReader.readLine()) != null) {
                str += line;
            }
            bufferedClobReader.close();
        } catch (IOException e) {
            throw new SQLException(e.toString());
        }

        return str;
    }

    /**
     * 返回文件大小
     * 如果大于1MB，则以MB为单位，返回两位小数单位
     * 如果大小1KB，则以KB为单位，返回整数，
     * 如果小于1KB，则以Byte为单位
     *
     * @param fileSize
     * @return
     */
    public static String getFileSize(int fileSize) {
        return getFileSize((long) fileSize);
    }

    /**
     * 返回文件大小
     * 如果大于1MB，则以MB为单位，返回两位小数单位
     * 如果大小1KB，则以KB为单位，返回整数，
     * 如果小于1KB，则以Byte为单位
     *
     * @param fileSize
     * @return
     */
    public static String getFileSize(long fileSize) {
        String reStr = "";
        long Igb, Imb = 0, temp = 0, Ikb = 0, Ib = 0;
        if (fileSize > 1024 * 1024 * 1024) {
            Igb = fileSize / (1024 * 1024 * 1024);
            temp = (fileSize % (1024 * 1024 * 1024)) * 100 / (1024 * 1024 * 1024);
            reStr = Igb + "." + temp + "GB";
        } else if (fileSize > 1024 * 1024) {
            Imb = fileSize / (1024 * 1024);
            temp = (fileSize % (1024 * 1024)) * 100 / (1024 * 1024);
            reStr = Imb + "." + temp + "MB";
        } else if (fileSize > 1024) {
            Ikb = fileSize / 1024;
            reStr = Ikb + "KB";
        } else {
            Ib = fileSize;
            reStr = Ib + "字节";
        }
        return reStr;
    }

    /**
     * 取得文件后缀等用
     * 如aaaa.txt
     * 返回txt
     *
     * @param source
     * @param key
     * @return
     */
    public static String getLastIndexOfString(String source, String key) {
        int k = source.lastIndexOf(key);
        return source.substring(k + 1, source.length());
    }

    /**
     * 追加字符串
     *
     * @param str1  原字符串
     * @param str2  要追加的字符串
     * @param count 总位数
     * @param right 方向，true是向右，false是向左
     * @return 追加后的字符串
     */
    public static String AppendStr(String str1, String str2, int count, boolean right) {
        String newStr = "";
        for (int i = 0; i < (count - str1.length()); i++)
            newStr += str2;
        if (right)
            return str1 + newStr;
        else
            return newStr + str1;
    }

    /**
     * 将字符串中的变量（以“%”为前导后接数字）使用values数组中的内容进行替换。
     * 替换的过程是不进行嵌套的，即如果替换的内容中包含变量表达式时不会替换。
     *
     * @param source 带参数的原字符串
     * @param values 替换用的字符串数组
     * @return 替换后的字符串
     */
    public static String getReplaceString(String source, String[] values) {
        return getReplaceString("%", source, values);
    }

    /**
     * 将字符串中的变量使用values数组中的内容进行替换。
     * 替换的过程是不进行嵌套的，即如果替换的内容中包含变量表达式时不会替换。
     *
     * @param prefix 变量前缀字符串
     * @param source 带参数的原字符串
     * @param values 替换用的字符串数组
     * @return 替换后的字符串。
     *         如果前缀为null则使用“%”作为前缀；
     *         如果source或者values为null或者values的长度为0则返回source；
     *         如果values的长度大于参数的个数，多余的值将被忽略；
     *         如果values的长度小于参数的个数，则后面的所有参数都使用最后一个值进行替换。
     */
    public static String getReplaceString(String prefix, String source,
                                          String[] values) {
        String result = source;
        if (source == null || values == null || values.length < 1) {
            return source;
        }
        if (prefix == null) {
            prefix = "%";
        }

        for (int i = 0; i < values.length; i++) {
            String argument = prefix + Integer.toString(i + 1);
            int index = result.indexOf(argument);
            if (index != -1) {
                String temp = result.substring(0, index);
                if (i < values.length) {
                    temp += values[i];
                } else {
                    temp += values[values.length - 1];
                }
                temp += result.substring(index + 2);
                result = temp;
            }
        }
        return result;
    }

    /**
     * 过滤系统错误
     *
     * @param e
     * @param filterPackages
     * @return
     * @throws IOException
     */
    public static String filterStackTrace(Throwable e, String filterPackages[])
            throws IOException {
        if (e == null) return "No exception founded";
        StringWriter expout = new StringWriter();
        StringBuffer out = new StringBuffer();
        e.printStackTrace(new PrintWriter(expout));
        BufferedReader br = new BufferedReader(new StringReader(expout.toString()));
        String s1;
        while ((s1 = br.readLine()) != null) {
            boolean f = false;
            for (int i = 0; i < filterPackages.length; i++) {
                if (s1.indexOf(filterPackages[i]) == -1)
                    continue;
                f = true;
                break;
            }
            if (!f) {
                out.append(s1);
                out.append("\n");
            }
        }
        return out.toString();
    }

    /**
     * @param main
     * @param s
     * @return
     */
    public static String toString(String[] main, String s) {
        if (main == null || main.length == 0) return "";
        String returnStr = s;
        for (int i = 0; i < main.length; i++) {
            returnStr += main[i] + s;
        }
        return returnStr;
    }

    /**
     * 取得星期大写
     *
     * @param i
     * @return
     */
    public static String getWeekStr(int i) {
        String[] s = new String[]{"星期日", "星期一", "星期二",
                                  "星期三", "星期四", "星期五", "星期六"};
        return s[i];
    }

    /**
     * @return
     */
    public static String trim(String s) {
        if (s == null) s = "";
        return s.trim();
    }

    /**
     * 去掉首尾字符
     *
     * @param str
     * @param ts
     * @return
     */
    public static String trimBeginEnd(String str, String ts) {
        if (str == null) return "";
        while (str.startsWith(ts)) str = str.substring(ts.length(), str.length());
        while (str.endsWith(ts)) str = str.substring(0, str.length() - ts.length());
        return str;
    }

    /**
     * 去掉首尾空格，包括全角，半角
     *
     * @param s
     * @return
     */
    public static String trimBeginEndBlank(String s) {
        if (s == null) return "";
        s = s.trim();
        s = StringUtil.trimBeginEnd(s, " ");
        s = StringUtil.trimBeginEnd(s, "　");
        return s;
    }

    public static void main(String[] arg) {
        String s = "ddddsafdasdfddd", ts = "dd";
        System.out.println(StringUtil.trimBeginEnd(s, ts));
    }
}