字符串常用数据（工具类的处理）

package com.bmcc.framework.util;

import java.util.ArrayList;
import java.util.UUID;

/**
 * 
 * @author yuhu.zhang
 * 
 */
public class CMyString {

    /** 默认字符编码集 */
    public static String ENCODING_DEFAULT = "UTF-8";

    public static String GET_ENCODING_DEFAULT = "UTF-8";

    public CMyString() {
        super();
    }

    // ==============================================================================
    // 常用字符串函数

    /**
     * null转""并去除掉空格
     * 
     * @param target 需要处理的字符串
     * @return String
     */
    public static String trim2Empty(String target) {
        return isEmpty(target) ? "" : target.trim();
    }

    /**
     * ""转null并去除掉空格
     * 
     * @param target 需要处理的字符串
     * @return String
     */
    public static String trim2Null(String target) {
        return isEmpty(target) ? null : target.trim();
    }

    /**
     * 是否为空
     * 
     * @param target 需要判断的字符串
     * @return boolean 空-true 非空-false
     */
    public static boolean isEmpty(String target) {
        return target == null || target.trim().length() == 0;
    }

    /**
     * 是否为非空
     * 
     * @param target 需要判断的字符串
     * @return boolean 空-false 非空-true
     */
    public static boolean isNotEmpty(String target) {
        return target != null && target.trim().length() > 0;
    }

    /**
     * 字符串显示处理函数：若为空对象，则返回指定的字符串
     * 
     * @see showObj( String _sValue, String _sReplaceIfNull )
     */
    public static String showObj(Object p_sValue) {
        return showObj(p_sValue, "");
    }

    /**
     * 字符串显示处理函数：若为空对象，则返回指定的字符串
     * 
     * @param _sValue         指定的字符串
     * @param _sReplaceIfNull 当_sValue==null时的替换显示字符串；可选参数，缺省值为空字符串（""）
     * @return 处理后的字符串
     */
    public static String showObj(Object _sValue, String _sReplaceIfNull) {
        if (_sValue == null)
            return _sReplaceIfNull;
        return _sValue.toString();
    }

    /**
     * 字符串显示处理函数：若为空对象，则返回指定的字符串
     * 
     * @see show( String _sValue, String _sReplaceIfNull )
     */
    public static String show(String p_sValue) {
        return show(p_sValue, "");
    }

    /**
     * 字符串显示处理函数：若为空对象，则返回指定的字符串
     * 
     * @param _sValue         指定的字符串
     * @param _sReplaceIfNull 当_sValue==null时的替换显示字符串；可选参数，缺省值为空字符串（""）
     * @return 处理后的字符串
     */
    public static String show(String _sValue, String _sReplaceIfNull) {
        return (_sValue == null ? _sReplaceIfNull : _sValue);
    }

    /**
     * 扩展字符串长度；若长度不足，则是用指定的字符串填充
     * 
     * @param _string      要扩展的字符串
     * @param _length      扩展后的字符串长度。
     * @param _chrFill     扩展时，用于填充的字符。
     * @param _bFillOnLeft 扩展时，是否为左填充（扩展）；否则，为右填充
     * @return 长度扩展后的字符串
     */
    public static String expandStr(String _string, int _length, char _chrFill, boolean _bFillOnLeft) {
        int nLen = _string.length();
        if (_length <= nLen)
            return _string; // 长度已够
        // else,扩展字符串长度
        String sRet = _string;
        for (int i = 0; i < _length - nLen; i++) {
            sRet = (_bFillOnLeft ? _chrFill + sRet : sRet + _chrFill); // 填充
        }
        return sRet;
    }

    /**
     * 设置字符串最后一位为指定的字符
     * 
     * @param _string 指定的字符串
     * @param _chrEnd 指定字符，若字符串最后一位不是该字符，则在字符串尾部追加该字符
     * @return 处理后的字符串
     */
    public static String setStrEndWith(String _string, char _chrEnd) {
        if (_string == null)
            return null;
        if (_string.charAt(_string.length() - 1) != _chrEnd)
            return _string + _chrEnd;
        // else
        return _string;
    }

    /**
     * 构造指定长度的空格字符串
     * 
     * @param _length 指定长度
     * @return 指定长度的空格字符串
     */
    public static String makeBlanks(int _length) {
        if (_length < 1)
            return "";
        StringBuffer buffer = new StringBuffer(_length);
        for (int i = 0; i < _length; i++) {
            buffer.append(' ');
        }
        return buffer.toString();
    }

    // =============================================================================
    // 字符串替换

    /**
     * 字符串替换函数：用于将指定字符串中指定的字符串替换为新的字符串。
     * 
     * @param _strSrc 源字符串。
     * @param _strOld 被替换的旧字符串
     * @param _strNew 用来替换旧字符串的新字符串
     * @return 替换处理后的字符串
     */
    public static String replaceStr(String _strSrc, String _strOld, String _strNew) {
        if (_strSrc == null || _strNew == null || _strOld == null)
            return _strSrc;

        // 提取源字符串对应的字符数组
        char[] srcBuff = _strSrc.toCharArray();
        int nSrcLen = srcBuff.length;
        if (nSrcLen == 0)
            return "";

        // 提取旧字符串对应的字符数组
        char[] oldStrBuff = _strOld.toCharArray();
        int nOldStrLen = oldStrBuff.length;
        if (nOldStrLen == 0 || nOldStrLen > nSrcLen)
            return _strSrc;

        StringBuffer retBuff = new StringBuffer((nSrcLen * (1 + _strNew.length() / nOldStrLen)));

        int i, j, nSkipTo;
        boolean bIsFound = false;

        i = 0;
        while (i < nSrcLen) {
            bIsFound = false;

            // 判断是否遇到要找的字符串
            if (srcBuff[i] == oldStrBuff[0]) {
                for (j = 1; j < nOldStrLen; j++) {
                    if (i + j >= nSrcLen)
                        break;
                    if (srcBuff[i + j] != oldStrBuff[j])
                        break;
                }
                bIsFound = (j == nOldStrLen);
            }

            // 若找到则替换，否则跳过
            if (bIsFound) { // 找到
                retBuff.append(_strNew);
                i += nOldStrLen;
            } else { // 没有找到
                if (i + nOldStrLen >= nSrcLen) {
                    nSkipTo = nSrcLen - 1;
                } else {
                    nSkipTo = i;
                }
                for (; i <= nSkipTo; i++) {
                    retBuff.append(srcBuff[i]);
                }
            }
        }
        srcBuff = null;
        oldStrBuff = null;
        return retBuff.toString();
    }

    /**
     * 字符串替换函数：用于将指定字符串中指定的字符串替换为新的字符串。
     * 
     * @param _strSrc 源字符串。
     * @param _strOld 被替换的旧字符串
     * @param _strNew 用来替换旧字符串的新字符串
     * @return 替换处理后的字符串
     */
    public static String replaceStr(StringBuffer _strSrc, String _strOld, String _strNew) {
        if (_strSrc == null)
            return null;

        // 提取源字符串对应的字符数组
        int nSrcLen = _strSrc.length();
        if (nSrcLen == 0)
            return "";

        // 提取旧字符串对应的字符数组
        char[] oldStrBuff = _strOld.toCharArray();
        int nOldStrLen = oldStrBuff.length;
        if (nOldStrLen == 0 || nOldStrLen > nSrcLen)
            return _strSrc.toString();

        StringBuffer retBuff = new StringBuffer((nSrcLen * (1 + _strNew.length() / nOldStrLen)));

        int i, j, nSkipTo;
        boolean bIsFound = false;

        i = 0;
        while (i < nSrcLen) {
            bIsFound = false;

            // 判断是否遇到要找的字符串
            if (_strSrc.charAt(i) == oldStrBuff[0]) {
                for (j = 1; j < nOldStrLen; j++) {
                    if (i + j >= nSrcLen)
                        break;
                    if (_strSrc.charAt(i + j) != oldStrBuff[j])
                        break;
                }
                bIsFound = (j == nOldStrLen);
            }

            // 若找到则替换，否则跳过
            if (bIsFound) { // 找到
                retBuff.append(_strNew);
                i += nOldStrLen;
            } else { // 没有找到
                if (i + nOldStrLen >= nSrcLen) {
                    nSkipTo = nSrcLen - 1;
                } else {
                    nSkipTo = i;
                }
                for (; i <= nSkipTo; i++) {
                    retBuff.append(_strSrc.charAt(i));
                }
            }
        }
        oldStrBuff = null;
        return retBuff.toString();
    }

    // ==============================================================================
    // 字符编码处理函数

    /**
     * 字符串编码转换函数，用于将指定编码的字符串转换为标准（Unicode）字符串
     * 
     * @see getStr( String _strSrc, String _encoding )
     */
    public static String getStr(String _strSrc) {
        return getStr(_strSrc, ENCODING_DEFAULT);
    }

    /**
     * 字符转换函数，处理中文问题
     * 
     * @param _strSrc      源字符串
     * @param _bPostMethod 提交数据的方式（Get方式采用GET_ENCODING_DEFAULT字符集，
     *                     Post方式采用ENCODING_DEFAULT字符集）
     * @return
     */
    public static String getStr(String _strSrc, boolean _bPostMethod) {
        return getStr(_strSrc, (_bPostMethod ? ENCODING_DEFAULT : GET_ENCODING_DEFAULT));
    }

    /**
     * 字符串编码转换函数，用于将指定编码的字符串转换为标准（Unicode）字符串
     * <p>
     * Purpose: 转换字符串内码，用于解决中文显示问题
     * </p>
     * <p>
     * Usage： 在页面切换时，获取并显示中文字符串参数时可用。
     * </p>
     * 
     * @param _strSrc   需要转换的字符串
     * @param _encoding 指定字符串（_strSrc）的编码方式；可选参数，缺省值为ENCODING_DEFAULT
     * @return
     */
    public static String getStr(String _strSrc, String _encoding) {
        if (_encoding == null || _encoding.length() == 0)
            return _strSrc;

        try {
            byte[] byteStr = new byte[_strSrc.length()];
            char[] charStr = _strSrc.toCharArray();
            for (int i = byteStr.length - 1; i >= 0; i--) {
                byteStr[i] = (byte) charStr[i];
            }
            return new String(byteStr, _encoding);
        } catch (Exception ex) {
            return _strSrc;
        }
    }

    /**
     * 提取字符串UTF8编码的字节流
     * <p>
     * 说明：等价于 <code>_string.getBytes("UTF8")</code>
     * </p>
     * 
     * @param _string 源字符串
     * @return UTF8编码的字节数组
     */
    public static byte[] getUTF8Bytes(String _string) {
        char[] c = _string.toCharArray();
        int len = c.length;

        // Count the number of encoded bytes...
        int count = 0;
        for (int i = 0; i < len; i++) {
            int ch = c[i];
            if (ch <= 0x7f) {
                count++;
            } else if (ch <= 0x7ff) {
                count += 2;
            } else {
                count += 3;
            }
        }

        // Now return the encoded bytes...
        byte[] b = new byte[count];
        int off = 0;
        for (int i = 0; i < len; i++) {
            int ch = c[i];
            if (ch <= 0x7f) {
                b[off++] = (byte) ch;
            } else if (ch <= 0x7ff) {
                b[off++] = (byte) ((ch >> 6) | 0xc0);
                b[off++] = (byte) ((ch & 0x3f) | 0x80);
            } else {
                b[off++] = (byte) ((ch >> 12) | 0xe0);
                b[off++] = (byte) (((ch >> 6) & 0x3f) | 0x80);
                b[off++] = (byte) ((ch & 0x3f) | 0x80);
            }
        }
        return b;
    }

    public static String getUTF8String(byte[] b) {
        return getUTF8String(b, 0, b.length);
    }

    /**
     * 从指定的字节数组中提取UTF8编码的字符串
     * <p>
     * 说明：函数等价于 <code> new String(b,"UTF8") </code>
     * </p>
     * 
     * @param b   指定的字节数组（UTF8编码）
     * @param off 开始提取的字节起始位置；可选参数，缺省值为0；
     * @param len 提取的字节数；可选择书，缺省值为全部。
     * @return 提取后得到的字符串。
     */
    public static String getUTF8String(byte[] b, int off, int len) {
        // First, count the number of characters in the sequence
        int count = 0;
        int max = off + len;
        int i = off;
        while (i < max) {
            int c = b[i++] & 0xff;
            switch (c >> 4) {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
            case 6:
            case 7:
                // 0xxxxxxx
                count++;
                break;
            case 12:
            case 13:
                // 110xxxxx 10xxxxxx
                if ((b[i++] & 0xc0) != 0x80) {
                    throw new IllegalArgumentException();
                }
                count++;
                break;
            case 14:
                // 1110xxxx 10xxxxxx 10xxxxxx
                if (((b[i++] & 0xc0) != 0x80) || ((b[i++] & 0xc0) != 0x80)) {
                    throw new IllegalArgumentException();
                }
                count++;
                break;
            default:
                // 10xxxxxx, 1111xxxx
                throw new IllegalArgumentException();
            }
        }
        if (i != max) {
            throw new IllegalArgumentException();
        }
        // Now decode the characters...
        char[] cs = new char[count];
        i = 0;
        while (off < max) {
            int c = b[off++] & 0xff;
            switch (c >> 4) {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
            case 6:
            case 7:
                // 0xxxxxxx
                cs[i++] = (char) c;
                break;
            case 12:
            case 13:
                // 110xxxxx 10xxxxxx
                cs[i++] = (char) (((c & 0x1f) << 6) | (b[off++] & 0x3f));
                break;
            case 14:
                // 1110xxxx 10xxxxxx 10xxxxxx
                int t = (b[off++] & 0x3f) << 6;
                cs[i++] = (char) (((c & 0x0f) << 12) | t | (b[off++] & 0x3f));
                break;
            default:
                // 10xxxxxx, 1111xxxx
                throw new IllegalArgumentException();
            }
        }
        return new String(cs, 0, count);
    }

    // ==============================================================================
    // 字符串显示处理函数

    /**
     * 将字节数据输出为16进制数表示的字符串
     * 
     * @see byteToHexString( byte[] _bytes, char _delim )
     */
    public static String byteToHexString(byte[] _bytes) {
        return byteToHexString(_bytes, ',');
    }

    /**
     * 将字节数据输出为16进制无符号数表示的字符串
     * 
     * @param _bytes 字节数组
     * @param _delim 字节数据显示时，字节之间的分隔符；可选参数，缺省值为','
     * @return 16进制无符号数表示的字节数据
     */
    public static String byteToHexString(byte[] _bytes, char _delim) {
        String sRet = "";
        for (int i = 0; i < _bytes.length; i++) {
            if (i > 0) {
                sRet += _delim;
            }
            sRet += Integer.toHexString(_bytes[i]);
        }
        return sRet;
    }

    /**
     * 将字节数据输出为指定进制数表示的字符串（注意：负数带有负号）
     * 
     * @param _bytes 字节数组
     * @param _delim 字节数据显示时，字节之间的分隔符；可选参数，缺省值为','
     * @param _radix 进制数（如16进制）
     * @return 指定进制数表示的字节数据（负数带由负号）
     */
    public static String byteToString(byte[] _bytes, char _delim, int _radix) {
        String sRet = "";
        for (int i = 0; i < _bytes.length; i++) {
            if (i > 0) {
                sRet += _delim;
            }
            sRet += Integer.toString(_bytes[i], _radix);
        }
        return sRet;
    }

    // ==============================================================================
    // 字符串过滤函数

    /**
     * SQL语句特殊字符过滤处理函数
     * <p>
     * 用于：构造SQL语句时，填充字符串参数时使用
     * </p>
     * <p>
     * 如：
     * <code>String strSQL = "select * from tbName where Name='"+CMyString.filterForSQL("a'bc")+"'" </code>
     * </p>
     * <p>
     * 说明：需要处理的特殊字符及对应转化规则：如： <code> ' ---&gt;''</code>
     * </p>
     * <p>
     * 不允许使用的特殊字符： <code> !@#$%^&*()+|-=\\;:\",./&lt;&gt;? </code>
     * </p>
     * 
     * @param _sContent 需要处理的字符串
     * @return 过滤处理后的字符串
     */
    public static String filterForSQL(String _sContent) {
        if (_sContent == null)
            return "";

        int nLen = _sContent.length();
        if (nLen == 0)
            return "";

        char[] srcBuff = _sContent.toCharArray();
        StringBuffer retBuff = new StringBuffer((int) (nLen * 1.5));

        for (int i = 0; i < nLen; i++) {
            char cTemp = srcBuff[i];
            switch (cTemp) {
            case '\'': {
                retBuff.append("''");
                break;
            }
            case ';':// 为了查询Unicode字符
                boolean bSkip = false;
                for (int j = (i + 1); j < nLen && !bSkip; j++) {
                    char cTemp2 = srcBuff[j];
                    if (cTemp2 == ' ')
                        continue;
                    if (cTemp2 == '&')
                        retBuff.append(';');
                    bSkip = true;
                }
                if (!bSkip)
                    retBuff.append(';');
                break;
            default:
                retBuff.append(cTemp);
            }// case
        }

        return retBuff.toString();
    }

    /**
     * HTML元素value值过滤处理函数：将 <code> & &lt; &gt;\ </code> 等特殊字符作转化处理
     * 
     * @sample <code>
     *    &lt;input type="text" name="Name" value="<%=CMyString.filterForHTMLValue(sContent)%>"&gt;
     * </code>
     * @param _sContent 指定的文本内容
     * @return 处理后的文本内容
     */
    public static String filterForHTMLValue(String _sContent) {
        if (_sContent == null)
            return "";

        char[] srcBuff = _sContent.toCharArray();
        int nLen = srcBuff.length;
        if (nLen == 0)
            return "";

        StringBuffer retBuff = new StringBuffer((int) (nLen * 1.8));

        for (int i = 0; i < nLen; i++) {
            char cTemp = srcBuff[i];
            switch (cTemp) {
            case '&': // 转化：& -->&amp;
                // 处理unicode代码
                if ((i + 1) < nLen) {
                    cTemp = srcBuff[i + 1];
                    if (cTemp == '#')
                        retBuff.append("&");
                    else
                        retBuff.append("&amp;");
                } else
                    retBuff.append("&amp;");
                break;
            case '<': // 转化：< --> &lt;
                retBuff.append("&lt;");
                break;
            case '>': // 转化：> --> &gt;
                retBuff.append("&gt;");
                break;
            case '\"': // 转化：" --> &quot;
                retBuff.append("&quot;");
                break;
            default:
                retBuff.append(cTemp);
            }// case
        }

        return retBuff.toString();
    }

    /**
     * URL过滤处理函数：将 <code> # & </code> 等特殊字符作转化处理
     * 
     * @param _sContent 指定的URL内容
     * @return 处理后的字符串
     */
    public static String filterForUrl(String _sContent) {
        if (_sContent == null)
            return "";

        char[] srcBuff = _sContent.toCharArray();
        int nLen = srcBuff.length;
        if (nLen == 0)
            return "";

        StringBuffer retBuff = new StringBuffer((int) (nLen * 1.8));

        for (int i = 0; i < nLen; i++) {
            char cTemp = srcBuff[i];
            switch (cTemp) {
            case '%':
                retBuff.append("%25");
                break;
            case '?':
                retBuff.append("%3F");
                break;
            case '#': // 转化：# --> %23
                retBuff.append("%23");
                break;
            case '&': // 转化：& --> %26
                retBuff.append("%26");
                break;
            case ' ': // 转化：空格 --> %20
                retBuff.append("%20");
                break;
            default:
                retBuff.append(cTemp);
            }// case
        }

        return retBuff.toString();
    }

    /**
     * JavaScript过滤处理函数：将指定文本中的 <code> " \ \r \n</code> 等特殊字符做转化处理
     * 
     * @sample <code>
     *      <br>&lt;script language="javascript"&gt;
     *      <br>     document.getElementById("id_txtName").value = "<%=CMyString.filterForJs(sValue)%>";
     *      <br>&lt;/script&gt;
     * </code>
     * @param _sContent 指定的javascript文本
     * @return 转化处理后的字符串
     */
    public static String filterForJs(String _sContent) {
        if (_sContent == null)
            return "";

        char[] srcBuff = _sContent.toCharArray();
        int nLen = srcBuff.length;
        if (nLen == 0)
            return "";

        StringBuffer retBuff = new StringBuffer((int) (nLen * 1.8));

        for (int i = 0; i < nLen; i++) {
            char cTemp = srcBuff[i];
            switch (cTemp) {
            case '"': // 转化：" --> \"
                retBuff.append("\\\"");
                break;
            case '\\': // 转化：\ --> \\
                retBuff.append("\\\\");
                break;
            case '\n':
                retBuff.append("\\n");
                break;
            case '\r':
                retBuff.append("\\r");
                break;
            case '\f':
                retBuff.append("\\f");
                break;
            case '\t':
                retBuff.append("\\t");
                break;
            case '/':
                retBuff.append("\\/");
                break;
            default:
                retBuff.append(cTemp);
            }// case
        }

        return retBuff.toString();
    }

    // ==============================================================================
    // 数字转化为字符串

    /**
     * 将指定整型值转化为字符串
     * 
     * @see number2Str( int _nValue, int _length, char _chrFill )
     */
    public static String number2Str(int _nValue) {
        return number2Str(_nValue, 0);
    }

    /**
     * 将指定整型值转化为字符串
     * 
     * @see number2Str( int _nValue, int _length, char _chrFill )
     */
    public static String number2Str(int _nValue, int _length) {
        return number2Str(_nValue, _length, '0');
    }

    /**
     * 将指定整型值转化为字符串
     * 
     * @param _nValue  指定整数
     * @param _length  转化后字符串长度；若实际长度小于该长度，则使用_chrFill左填充; 可选参数，缺省值0，表示按照实际长度，不扩展。
     * @param _chrFill 当整数的实际位数小于指定长度时的填充字符；可选参数，缺省值'0'
     * @return 转化后的字符串
     */
    public static String number2Str(int _nValue, int _length, char _chrFill) {
        String sValue = String.valueOf(_nValue);
        return expandStr(sValue, _length, _chrFill, true);
    }

    // 重载：使用long型数值
    /**
     * 将指定长整数转化为字符串
     * 
     * @see <code> number2Str( long _lValue, int _length, char _chrFill ) </code>
     */
    public static String number2Str(long _lValue) {
        return number2Str(_lValue, 0);
    }

    /**
     * 将指定长整数转化为字符串
     * 
     * @see <code> number2Str( long _lValue, int _length, char _chrFill ) </code>
     */
    public static String number2Str(long _lValue, int _length) {
        return number2Str(_lValue, _length, '0');
    }

    /**
     * 将指定长整数转化为字符串
     * 
     * @param _lValue  指定长整数
     * @param _length  转化后字符串长度；若实际长度小于该长度，则使用_chrFill左填充; 可选参数，缺省值0，表示按照实际长度，不扩展。
     * @param _chrFill 当整数的实际位数小于指定长度时的填充字符；可选参数，缺省值'0'
     * @return 转化后的字符串
     */
    public static String number2Str(long _lValue, int _length, char _chrFill) {
        String sValue = String.valueOf(_lValue);
        return expandStr(sValue, _length, _chrFill, true);
    }

    // ==============================================================================
    // 其他字符串处理函数

    /**
     * 字符串翻转：对于给定的字符串，按相反的顺序输出
     * 
     * @param _strSrc 指定的字符串
     * @return 翻转后的字符串
     */
    public static String circleStr(String _strSrc) {
        if (_strSrc == null)
            return null; // 错误保护

        String sResult = "";
        int nLength = _strSrc.length();
        for (int i = nLength - 1; i >= 0; i--) {
            sResult = sResult + _strSrc.charAt(i);
        }
        return sResult;
    }

    /**
     * 判断指定的字符是不是汉字，目前是通过判断其值是否大于7FH实现的。
     * 
     * @param c 指定的字符
     * @return 是否汉字
     */
    public final static boolean isChineseChar(int c) {
        return c > 0x7F;
    }

    /**
     * 返回指定字符的显示宽度，在目前的实现中，认为一个英文字符的显示宽度是1，一个汉字的显示宽度是2。
     * 
     * @param c 指定的字符
     * @return 指定字符的显示宽度
     */
    public final static int getCharViewWidth(int c) {
        return isChineseChar(c) ? 2 : 1;
    }

    /**
     * 返回指定字符串的显示宽度
     * 
     * @param s 指定的字符串
     * @return 指定字符串的显示宽度
     */
    public final static int getStringViewWidth(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }

        int iWidth = 0;
        int iLength = s.length();

        for (int i = 0; i < iLength; i++) {
            iWidth += getCharViewWidth(s.charAt(i));
        }

        return iWidth;
    }

    /**
     * 字符串截断函数：取指定字符串前部指定长度的字符串； 说明：英文和数字字符长度记1；中文字符长度记2。
     * 
     * @param _string    要截断的字符串。
     * @param _maxLength 截断长度。
     * @return 截断后的字符串。若指定长度小于字符串实际长度，则在返回的字符串后补“...”
     */
    public static String truncateStr(String _string, int _maxLength) {
        return truncateStr(_string, _maxLength, "..");
    }

    /**
     * 字符串截断函数：取指定字符串前部指定长度的字符串； 说明：英文和数字字符长度记1；中文字符长度记2。
     * 
     * @param _string    要截断的字符串。
     * @param _maxLength 截断长度。
     * @param _sExt      在截断后的字符串上的附加的字符串
     * @return 截断后的字符串
     */
    public static String truncateStr(String _string, int _maxLength, String _sExt) {
        if (_string == null) {
            return null;
        }

        if (_sExt == null) {
            _sExt = "..";
        }

        int nSrcLen = getStringViewWidth(_string);
        if (nSrcLen <= _maxLength) {
            // 源字符串太短，不需要截断
            return _string;
        }

        int nExtLen = getStringViewWidth(_sExt);
        if (nExtLen >= _maxLength) {
            // 目标长度太短（小于了附加字符串的长度），无法截断。
            return _string;
        }

        int iLength = _string.length();
        int iRemain = _maxLength - nExtLen;
        StringBuffer sb = new StringBuffer(_maxLength + 2); // 附加的“2”是没有意义的，只是为了容错

        for (int i = 0; i < iLength; i++) {
            char aChar = _string.charAt(i);
            int iNeed = getCharViewWidth(aChar);
            if (iNeed > iRemain) {
                sb.append(_sExt);
                break;
            }
            sb.append(aChar);
            iRemain = iRemain - iNeed;
        }

        return sb.toString();
    }

    /**
     * 校验当前字符是否是合法的XML字符
     * 
     * @param _char 需要校验的字符
     * @return
     */
    public static boolean isValidCharOfXML(char _char) {
        if (_char == 0x9 || _char == 0xA || _char == 0xD || (0x20 <= _char && _char <= 0xD7FF)
                || (0xE000 <= _char && _char <= 0xFFFD) || (0x10000 <= _char && _char <= 0x10FFFF)) {
            return true;
        }
        return false;
    }

    /**
     * 计算字符串所占的字节数；
     * <p>
     * 说明：英文和数字字符长度记1；中文字符长度记2。
     * </p>
     * 
     * @param _string 要截断的字符串。
     * @return 截断后的字符串。若指定长度小于字符串实际长度，则在返回的字符串后补“...”
     */
    public static int getBytesLength(String _string) {
        if (_string == null)
            return 0;

        char[] srcBuff = _string.toCharArray();

        int nGet = 0; // 已经取得的字符串长度（长度：英文字符记1，中文字符记2）
        for (int i = 0; i < srcBuff.length; i++) {
            char aChar = srcBuff[i];
            nGet += (aChar <= 0x7f ? 1 : 2); // （长度：英文字符记1，中文字符记2）
        }
        return nGet;
    }

    public static String[] split(String _str, String _sDelim) {
        // String[] str
        if (_str == null || _sDelim == null) {
            return new String[0];
        }

        java.util.StringTokenizer stTemp = new java.util.StringTokenizer(_str, _sDelim);
        int nSize = stTemp.countTokens();
        if (nSize == 0) {
            return new String[0];
        }

        String[] str = new String[nSize];
        int i = 0;
        while (stTemp.hasMoreElements()) {
            str[i] = stTemp.nextToken();
            i++;
        }
        return str;
    }

    /**
     * 获取按照指定的分隔符截取到的字符个数
     * 
     * @param _str    指定的字符数
     * @param _sDelim 指定的分隔符
     * @return 分隔的字符个数（int）
     */
    public static int countTokens(String _str, String _sDelim) {
        java.util.StringTokenizer stTemp = new java.util.StringTokenizer(_str, _sDelim);
        return stTemp.countTokens();
    }

    /**
     * @param _str    if <code>null</code> or empty string return an array with zero
     *                length.
     * @param _sDelim if <code>null</code> or empty string then this will set to
     *                <code>,</code>
     * @return
     */
    public static int[] splitToInt(String _str, String _sDelim) {
        if (isEmpty(_str)) {
            return new int[0];
        }

        // to avoid null pointer exception throw
        if (isEmpty(_sDelim)) {
            _sDelim = ",";
        }

        java.util.StringTokenizer stTemp = new java.util.StringTokenizer(_str, _sDelim);
        int[] arInt = new int[stTemp.countTokens()];
        int nIndex = 0;
        String sValue;
        while (stTemp.hasMoreElements()) {
            sValue = (String) stTemp.nextElement();
            arInt[nIndex] = Integer.parseInt(sValue.trim());
            nIndex++;
        }
        return arInt;
    }

    /**
     * 判断字符串中是否包含中文字符 <BR>
     * 如果包含,则返回 <code>true<code>
     * 
     * @param _str 指定的字符串
     * @return
     */
    public static final boolean isContainChineseChar(String _str) {
        if (_str == null) {
            return false;
        }

        return (_str.getBytes().length != _str.length());
    }

    /**
     * 将一个数组按照给定的连接符联结起来
     * 
     * @param _arColl     进行操作的数组
     * @param _sSeparator 连接符
     * @return 连接后的字符串
     */
    public static String join(ArrayList<Object> _arColl, String _sSeparator) {
        // check parameters
        if (_arColl == null)
            return null;

        // invoke reload-method and return
        return join(_arColl.toArray(), _sSeparator);
    }

    /**
     * 将一个数组按照给定的连接符联结起来
     * 
     * @param _arColl     进行操作的数组
     * @param _sSeparator 连接符
     * @return 连接后的字符串
     */
    public static String join(Object[] _arColl, String _sSeparator) {
        // check parameters
        if (_arColl == null || _arColl.length == 0 || _sSeparator == null)
            return null;

        if (_arColl.length == 1)
            return _arColl[0].toString();

        // resolve the demiter into the string
        StringBuffer result = new StringBuffer(_arColl[0].toString());
        for (int i = 1; i < _arColl.length; i++) {
            result.append(_sSeparator);
            result.append(_arColl[i].toString());
        }

        // return the result
        return result.toString();
    }

    public static int getInt(Object _strSrc, int _nDefault) {
        int nRet = _nDefault;
        if (_strSrc == null) {
            return nRet;
        } else {
            try {
                nRet = Integer.parseInt(_strSrc.toString());
            } catch (Exception e) {
            }
            return nRet;
        }
    }

    /**
     * 
     * @return String
     */
    public static String getUuid() {
        return UUID.randomUUID().toString().replaceAll("-", "");
    }

}