java 對常用字串操作的封裝

package com.wiker;

import java.beans.XMLDecoder;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang.RandomStringUtils;

import com.opensymphony.util.TextUtils;


/**
 * TODO: DOCUMENT ME!
 * 
 * @author Wiker
 */
public class StringUtil {
    private static Pattern numericPattern = Pattern.compile("^[0-9\\-]+$");
    private static Pattern integerPattern = Pattern.compile("^[0-9]+$");
    private static Pattern numericStringPattern = Pattern.compile("^[0-9\\-\\-]+$");
    private static Pattern floatNumericPattern = Pattern.compile("^[0-9\\.]+$");
    private static Pattern abcPattern = Pattern.compile("^[a-z|A-Z]+$");
    public static final String splitStrPattern = ",|，|;|；|、|\\.|。|-|_|\\(|\\)|\\[|\\]|\\{|\\}|\\\\|/| |　|\"";
    
    /**
     * 判斷是否數字表示
     * 
     * @param src
     *            源字串
     * @return 是否數字的標誌
     */
    public static boolean isNumeric(String src) {
        boolean return_value = false;
        if (src != null && src.length() > 0) {
            Matcher m = numericPattern.matcher(src);
            if (m.find()) {
                return_value = true;
            }
        }
        return return_value;
    }
    
    /**
     * 
     * 是否是數字。整數，沒有任何符號
     *
     * @param src
     * @return
     */
    public static boolean isInteger(String src){
        boolean return_value = false;
        if (src != null && src.length() > 0) {
            Matcher m = integerPattern.matcher(src);
            if (m.find()) {
                return_value = true;
            }
        }
        return return_value;
    }
    
    /**
     * 判斷是否數字
     * 
     * @param src
     *            源字串
     * @return 是否數字的標誌
     */
    public static boolean isNumericString(String src) {
        boolean return_value = false;
        if (src != null && src.length() > 0) {
            Matcher m = numericStringPattern.matcher(src);
            if (m.find()) {
                return_value = true;
            }
        }
        return return_value;
    }
    
    /**
     * 判斷是否純字母組合
     * 
     * @param src
     *            源字串
     * @return 是否純字母組合的標誌
     */
    public static boolean isABC(String src) {
        boolean return_value = false;
        if (src != null && src.length() > 0) {
            Matcher m = abcPattern.matcher(src);
            if (m.find()) {
                return_value = true;
            }
        }
        return return_value;
    }
    
    /**
     * 判斷是否浮點數字表示
     * 
     * @param src
     *            源字串
     * @return 是否數字的標誌
     */
    public static boolean isFloatNumeric(String src) {
        boolean return_value = false;
        if (src != null && src.length() > 0) {
            Matcher m = floatNumericPattern.matcher(src);
            if (m.find()) {
                return_value = true;
            }
        }
        return return_value;
    }
    
    /**
     * 把string array or list用給定的符號symbol連線成一個字串
     * 
     * @param array
     * @param symbol
     * @return
     */
    public static String joinString(List array, String symbol) {
        String result = "";
        if (array != null) {
            for (int i = 0; i < array.size(); i++) {
                String temp = array.get(i).toString();
                if (temp != null && temp.trim().length() > 0)
                    result += (temp + symbol);
            }
            if (result.length() > 1)
                result = result.substring(0, result.length() - 1);
        }
        return result;
    }
    
    /**
     * 擷取字串
     * 
     * @param subject
     * @param size
     * @return
     */
    public static String subStringNotEncode(String subject, int size) {
        if (subject != null && subject.length() > size) {
            subject = subject.substring(0, size) + "...";
        }
        return subject;
    }
    
    public static String subString(String subject, int size) {
        subject = TextUtils.htmlEncode(subject);
        if (subject.length() > size) {
            subject = subject.substring(0, size) + "...";
        }
        return subject;
    }
    
    /**
     * 擷取字串　超出的字元用symbol代替 　　
     * 
     * @param len
     *            　字串長度　長度計量單位為一個GBK漢字　　兩個英文字母計算為一個單位長度
     * @param str
     * @param symbol
     * @return
     */
    public static String getLimitLengthString(String str, int len, String symbol) {
        int iLen = len * 2;
        int counterOfDoubleByte = 0;
        String strRet = "";
        try {
            if (str != null) {
                byte[] b = str.getBytes("GBK");
                if (b.length <= iLen) {
                    return str;
                }
                for (int i = 0; i < iLen; i++) {
                    if (b[i] < 0) {
                        counterOfDoubleByte++;
                    }
                }
                if (counterOfDoubleByte % 2 == 0) {
                    strRet = new String(b, 0, iLen, "GBK") + symbol;
                    return strRet;
                } else {
                    strRet = new String(b, 0, iLen - 1, "GBK") + symbol;
                    return strRet;
                }
            } else {
                return "";
            }
        } catch (Exception ex) {
            return str.substring(0, len);
        } finally {
            strRet = null;
        }
    }
    
    /**
     * 擷取字串　超出的字元用symbol代替 　　
     * 
     * @param len
     *            　字串長度　長度計量單位為一個GBK漢字　　兩個英文字母計算為一個單位長度
     * @param str
     * @param symbol
     * @return12
     */
    public static String getLimitLengthString(String str, int len) {
        return getLimitLengthString(str, len, "...");
    }
    
    public static String subStr(String subject, int size) {
        subject = TextUtils.htmlEncode(subject);
        if (subject.length() > size) {
            subject = subject.substring(0, size);
        }
        return subject;
    }
    
    /**
     * 擷取字元，不轉碼
     * 
     * @param subject
     * @param size
     * @return
     */
    public static String subStrNotEncode(String subject, int size) {
        if (subject.length() > size) {
            subject = subject.substring(0, size);
        }
        return subject;
    }
    
    /**
     * 把string array or list用給定的符號symbol連線成一個字串
     * 
     * @param array
     * @param symbol
     * @return
     */
    public static String joinString(String[] array, String symbol) {
        String result = "";
        if (array != null) {
            for (int i = 0; i < array.length; i++) {
                String temp = array[i];
                if (temp != null && temp.trim().length() > 0)
                    result += (temp + symbol);
            }
            if (result.length() > 1)
                result = result.substring(0, result.length() - 1);
        }
        return result;
    }
    
    /**
     * 取得字串的實際長度（考慮了漢字的情況）
     * 
     * @param SrcStr
     *            源字串
     * @return 字串的實際長度
     */
    public static int getStringLen(String SrcStr) {
        int return_value = 0;
        if (SrcStr != null) {
            char[] theChars = SrcStr.toCharArray();
            for (int i = 0; i < theChars.length; i++) {
                return_value += (theChars[i] <= 255) ? 1 : 2;
            }
        }
        return return_value;
    }
    
    /**
     * 檢查聯絡人資訊是否填寫，電話，手機，email必須填至少一個，email填了的話檢查格式
     * 
     * @param phoneCity
     * @param phoneNumber
     * @param phoneExt
     * @param mobileNumber
     * @param email
     * @return
     */
    public static boolean checkContactInfo(String phoneCity, String phoneNumber, String phoneExt,
            String mobileNumber, String email) {
        String result = (phoneCity == null ? "" : phoneCity.trim())
                + (phoneNumber == null ? "" : phoneNumber.trim())
                + (phoneExt == null ? "" : phoneExt.trim())
                + (mobileNumber == null ? "" : mobileNumber.trim())
                + (email == null ? "" : email.trim());
        if (result.length() < 1)
            return false;
        if (!isEmail(email))
            return false;
        
        return true;
    }
    
    /**
     * 檢查資料串中是否包含非法字符集
     * 
     * @param str
     * @return [true]|[false] 包含|不包含
     */
    public static boolean check(String str) {
        String sIllegal = "'\"";
        int len = sIllegal.length();
        if (null == str)
            return false;
        for (int i = 0; i < len; i++) {
            if (str.indexOf(sIllegal.charAt(i)) != -1)
                return true;
        }
        
        return false;
    }
    
    /**
     * getHideEmailPrefix - 隱藏郵件地址字首。
     * 
     * @param email
     *            - EMail郵箱地址 例如: 
 
[email protected] 等等...
     * @return 返回已隱藏字首郵件地址, 如 *********@koubei.com.
     * @version 1.0 (2006.11.27) Wilson Lin
     */
    public static String getHideEmailPrefix(String email) {
        if (null != email) {
            int index = email.lastIndexOf('@');
            if (index > 0) {
                email = repeat("*", index).concat(email.substring(index));
            }
        }
        return email;
    }
    
    /**
     * repeat - 通過源字串重複生成N次組成新的字串。
     * 
     * @param src
     *            - 源字串 例如: 空格(" "), 星號("*"), "浙江" 等等...
     * @param num
     *            - 重複生成次數
     * @return 返回已生成的重複字串
     * @version 1.0 (2006.10.10) Wilson Lin
     */
    public static String repeat(String src, int num) {
        StringBuffer s = new StringBuffer();
        for (int i = 0; i < num; i++)
            s.append(src);
        return s.toString();
    }
    
    /**
     * 檢查是否是email, when null or '' return true
     * 
     * @param email
     * @return
     */
    public static boolean isEmail(String email) {
        if (email != null && email.trim().length() > 0) {
            if (!TextUtils.verifyEmail(email)) {
                return false;
            } else {
                return true;
            }
        }
        return false;
    }
    
    /**
     * 根據指定的字元把源字串分割成一個數組
     * 
     * @param src
     * @return
     */
    public static List<String> parseString2ListByCustomerPattern(String pattern, String src) {
        
        if (src == null)
            return null;
        List<String> list = new ArrayList<String>();
        String[] result = src.split(pattern);
        for (int i = 0; i < result.length; i++) {
            list.add(result[i]);
        }
        return list;
    }
    
    /**
     * 根據指定的字元把源字串分割成一個數組
     * 
     * @param src
     * @return
     */
    public static List<String> parseString2ListByPattern(String src) {
        String pattern = "，|,|、|。";
        return parseString2ListByCustomerPattern(pattern, src);
    }
    
    /**
     * 格式化一個float
     * 
     * @param format
     *            要格式化成的格式 such as #.00, #.#
     */
    
    public static String formatFloat(float f, String format) {
        DecimalFormat df = new DecimalFormat(format);
        return df.format(f);
    }
    
    /**
     * 判斷是否是空字串 null和"" 都返回 true
     * 
     * @param s
     * @return
     */
    public static boolean isEmpty(String s) {
        if (s != null && !s.equals("")) {
            return false;
        }
        return true;
    }
    
    /**
     * 自定義的分隔字串函式 例如: 1,2,3 =>[1,2,3] 3個元素 ,2,3=>[,2,3] 3個元素 ,2,3,=>[,2,3,]
     * 4個元素 ,,,=>[,,,] 4個元素
     * 5.22演算法修改，為提高速度不用正則表示式 兩個間隔符,,返回""元素
     * 
     * @param split
     *            分割字元 預設,
     * @param src
     *            輸入字串
     * @return 分隔後的list
     */
    public static List<String> splitToList(String split, String src) {
        // 預設,
        String sp = ",";
        if (split != null && split.length() == 1) {
            sp = split;
        }
        List<String> r = new ArrayList<String>();
        int lastIndex = -1;
        int index = src.indexOf(sp);
        if (-1 == index && src != null) {
            r.add(src);
            return r;
        }
        while (index >= 0) {
            if (index > lastIndex) {
                r.add(src.substring(lastIndex + 1, index));
            } else {
                r.add("");
            }
            
            lastIndex = index;
            index = src.indexOf(sp, index + 1);
            if (index == -1) {
                r.add(src.substring(lastIndex + 1, src.length()));
            }
        }
        return r;
    }
    
    /**
     * 把 名=值 引數錶轉換成字串 (a=1,b=2 =>a=1&b=2)
     * 
     * @param map
     * @return
     */
    public static String linkedHashMapToString(LinkedHashMap<String, String> map) {
        if (map != null && map.size() > 0) {
            String result = "";
            Iterator it = map.keySet().iterator();
            while (it.hasNext()) {
                String name = (String) it.next();
                String value = (String) map.get(name);
                result += (result.equals("")) ? "" : "&";
                result += String.format("%s=%s", name, value);
            }
            return result;
        }
        return null;
    }
    
    /**
     * 解析字串返回 名稱=值的引數表 (a=1&b=2 => a=1,b=2)
     * 
     * @see test.koubei.util.StringUtilTest#testParseStr()
     * @param str
     * @return
     */
    @SuppressWarnings("unchecked")
    public static LinkedHashMap<String, String> toLinkedHashMap(String str) {
        if (str != null && !str.equals("") && str.indexOf("=") > 0) {
            LinkedHashMap result = new LinkedHashMap();
            
            String name = null;
            String value = null;
            int i = 0;
            while (i < str.length()) {
                char c = str.charAt(i);
                switch (c) {
                    case 61: // =
                        value = "";
                        break;
                    case 38: // &
                        if (name != null && value != null && !name.equals("")) {
                            result.put(name, value);
                        }
                        name = null;
                        value = null;
                        break;
                    default:
                        if (value != null) {
                            value = (value != null) ? (value + c) : "" + c;
                        } else {
                            name = (name != null) ? (name + c) : "" + c;
                        }
                }
                i++;
                
            }
            
            if (name != null && value != null && !name.equals("")) {
                result.put(name, value);
            }
            
            return result;
            
        }
        return null;
    }
    
    /**
     * 根據輸入的多個解釋和下標返回一個值
     * 
     * @param captions
     *            例如:"無,愛乾淨,一般,比較亂"
     * @param index
     *            1
     * @return 一般
     */
    public static String getCaption(String captions, int index) {
        if (index > 0 && captions != null && !captions.equals("")) {
            String[] ss = captions.split(",");
            if (ss != null && ss.length > 0 && index < ss.length) {
                return ss[index];
            }
        }
        return null;
    }
    
    /**
     * 數字轉字串,如果num<=0 則輸出"";
     * 
     * @param num
     * @return
     */
    public static String numberToString(Object num) {
        if (num == null) {
            return null;
        } else if (num instanceof Integer && (Integer) num > 0) {
            return Integer.toString((Integer) num);
        } else if (num instanceof Long && (Long) num > 0) {
            return Long.toString((Long) num);
        } else if (num instanceof Float && (Float) num > 0) {
            return Float.toString((Float) num);
        } else if (num instanceof Double && (Double) num > 0) {
            return Double.toString((Double) num);
        } else {
            return "";
        }
    }
    
    /**
     * 貨幣轉字串
     * 
     * @param money
     * @param style
     *            樣式 [default]要格式化成的格式 such as #.00, #.#
     * @return
     */
    
    public static String moneyToString(Object money, String style) {
        if (money != null && style != null && (money instanceof Double || money instanceof Float)) {
            Double num = (Double) money;
            
            if (style.equalsIgnoreCase("default")) {
                // 預設樣式 0 不輸出 ,如果沒有輸出小數位則不輸出.0
                if (num == 0) {
                    // 不輸出0
                    return "";
                } else if ((num * 10 % 10) == 0) {
                    // 沒有小數
                    return Integer.toString((int) num.intValue());
                } else {
                    // 有小數
                    return num.toString();
                }
                
            } else {
                DecimalFormat df = new DecimalFormat(style);
                return df.format(num);
            }
        }
        return null;
    }
    
    /**
     * 在sou中是否存在finds 如果指定的finds字串有一個在sou中找到,返回true;
     * 
     * @param sou
     * @param find
     * @return
     */
    public static boolean strPos(String sou, String... finds) {
        if (sou != null && finds != null && finds.length > 0) {
            for (int i = 0; i < finds.length; i++) {
                if (sou.indexOf(finds[i]) > -1)
                    return true;
            }
        }
        return false;
    }
    
    public static boolean strPos(String sou, List<String> finds) {
        if (sou != null && finds != null && finds.size() > 0) {
            for (String s : finds) {
                if (sou.indexOf(s) > -1)
                    return true;
            }
        }
        return false;
    }
    
    public static boolean strPos(String sou, String finds) {
        List<String> t = splitToList(",", finds);
        return strPos(sou, t);
    }
    
    /**
     * 判斷兩個字串是否相等 如果都為null則判斷為相等,一個為null另一個not null則判斷不相等 否則如果s1=s2則相等
     * 
     * @param s1
     * @param s2
     * @return
     */
    public static boolean equals(String s1, String s2) {
        if (StringUtil.isEmpty(s1) && StringUtil.isEmpty(s2)) {
            return true;
        } else if (!StringUtil.isEmpty(s1) && !StringUtil.isEmpty(s2)) {
            return s1.equals(s2);
        }
        return false;
    }
    
    public static int toInt(String s) {
        if (s != null && !"".equals(s.trim())) {
            try {
                return Integer.parseInt(s);
            } catch (Exception e) {
                return 0;
            }
        }
        return 0;
    }
    
    public static double toDouble(String s) {
        if (s != null && !"".equals(s.trim())) {
            return Double.parseDouble(s);
        }
        return 0;
    }
    
    public static boolean isPhone(String phone) {
        if (phone == null && "".equals(phone)) {
            return false;
        }
        String[] strPhone = phone.split("-");
        try {
            for (int i = 0; i < strPhone.length; i++) {
                Long.parseLong(strPhone[i]);
            }
            
        } catch (Exception e) {
            return false;
        }
        return true;
        
    }
    
    /**
     * 把xml 轉為object
     * 
     * @param xml
     * @return
     */
    public static Object xmlToObject(String xml) {
        try {
            ByteArrayInputStream in = new ByteArrayInputStream(xml.getBytes("UTF8"));
            XMLDecoder decoder = new XMLDecoder(new BufferedInputStream(in));
            return decoder.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    
    /**
     * 按規定長度截斷字串，沒有...的省略符號
     * 
     * @param subject
     * @param size
     * @return
     */
    public static String subStringNoEllipsis(String subject, int size) {
        subject = TextUtils.htmlEncode(subject);
        if (subject.length() > size) {
            subject = subject.substring(0, size);
        }
        return subject;
    }
    
    public static long toLong(String s) {
        try {
            if (s != null && !"".equals(s.trim()))
                return Long.parseLong(s);
        } catch (Exception exception) {
        }
        return 0L;
    }
    
    public static String simpleEncrypt(String str) {
        if (str != null && str.length() > 0) {
            // str = str.replaceAll("0","a");
            str = str.replaceAll("1", "b");
            // str = str.replaceAll("2","c");
            str = str.replaceAll("3", "d");
            // str = str.replaceAll("4","e");
            str = str.replaceAll("5", "f");
            str = str.replaceAll("6", "g");
            str = str.replaceAll("7", "h");
            str = str.replaceAll("8", "i");
            str = str.replaceAll("9", "j");
        }
        return str;
        
    }
    
    /**
     * 過濾使用者輸入的URL地址（防治使用者廣告） 目前只針對以http或www開頭的URL地址
     * 本方法呼叫的正則表示式，不建議用在對效能嚴格的地方例如:迴圈及list頁面等
     * 
     * @param str
     *            需要處理的字串
     * @return 返回處理後的字串
     */
    public static String removeURL(String str) {
        if (str != null)
            str = str.toLowerCase().replaceAll("(http|www|com|cn|org|\\.)+", "");
        return str;
    }
    
    /**
     * 隨即生成指定位數的含數字驗證碼字串
     * 
     * @param bit
     *            指定生成驗證碼位數
     * @return String
     */
    public static String numRandom(int bit) {
        if (bit == 0)
            bit = 6; // 預設6位
        String str = "";
        str = "0123456789";// 初始化種子
        return RandomStringUtils.random(bit, str);// 返回6位的字串
    }
    
    /**
     * 隨即生成指定位數的含驗證碼字串
     * 
     * @param bit
     *            指定生成驗證碼位數
     * @return String
     */
    public static String random(int bit) {
        if (bit == 0)
            bit = 6; // 預設6位
        // 因為o和0,l和1很難區分,所以,去掉大小寫的o和l
        String str = "";
        str = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz";// 初始化種子
        return RandomStringUtils.random(bit, str);// 返回6位的字串
    }
    
    /**
     * 檢查字串是否屬於手機號碼
     * 
     * @param str
     * @return boolean
     */
    public static boolean isMobile(String str) {
        if (str == null || str.equals(""))
            return false;
        if (str.length() != 11 || !isNumeric(str))
            return false;
        if (!str.substring(0, 2).equals("13") && !str.substring(0, 2).equals("15")
                && !str.substring(0, 2).equals("18"))
            return false;
        return true;
    }
    
    /**
     * Wap頁面的非法字元檢查
     * 
     * @param str
     * @return
     */
    public static String replaceWapStr(String str) {
        if (str != null) {
            str = str.replaceAll("<span class=\"keyword\">", "");
            str = str.replaceAll("</span>", "");
            str = str.replaceAll("<strong class=\"keyword\">", "");
            str = str.replaceAll("<strong>", "");
            str = str.replaceAll("</strong>", "");
            
            str = str.replace('$', '＄');
            
            str = str.replaceAll("&", "＆");
            str = str.replace('&', '＆');
            
            str = str.replace('<', '＜');
            
            str = str.replace('>', '＞');
            
        }
        return str;
    }
    
    /**
     * 字串轉float 如果異常返回0.00
     * 
     * @param s
     *            輸入的字串
     * @return 轉換後的float
     */
    public static Float toFloat(String s) {
        try {
            return Float.parseFloat(s);
        } catch (NumberFormatException e) {
            return new Float(0);
        }
    }
    
    /**
     * 頁面中去除字串中的空格、回車、換行符、製表符
     * 
     * @param str
     * @return
     */
    public static String replaceBlank(String str) {
        if (str != null) {
            Pattern p = Pattern.compile("\\s*|\t|\r|\n");
            Matcher m = p.matcher(str);
            str = m.replaceAll("");
        }
        return str;
    }
    
    /**
     * 全形生成半形
     * 
     * @param str
     * @return
     */
    public static String Q2B(String QJstr) {
        String outStr = "";
        String Tstr = "";
        byte[] b = null;
        for (int i = 0; i < QJstr.length(); i++) {
            try {
                Tstr = QJstr.substring(i, i + 1);
                b = Tstr.getBytes("unicode");
            } catch (java.io.UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            if (b[3] == -1) {
                b[2] = (byte) (b[2] + 32);
                b[3] = 0;
                try {
                    outStr = outStr + new String(b, "unicode");
                } catch (java.io.UnsupportedEncodingException ex) {
                    ex.printStackTrace();
                }
            } else {
                outStr = outStr + Tstr;
            }
        }
        return outStr;
    }
    
    /**
     * 轉換編碼
     * 
     * @param s
     *            源字串
     * @param fencode
     *            源編碼格式
     * @param bencode
     *            目標編碼格式
     * @return 目標編碼
     */
    public static String changCoding(String s, String fencode, String bencode) {
        try {
            String str = new String(s.getBytes(fencode), bencode);
            return str;
        } catch (UnsupportedEncodingException e) {
            return s;
        }
    }
    
    /**
     * 除去html標籤
     * 
     * @param str
     * @return
     */
    public static String removeHTMLLableExe(String str) {
        str = stringReplace(str, ">\\s*<", "><");
        str = stringReplace(str, " ", " ");// 替換空格
        str = stringReplace(str, "<br ?/?>", "\n");// 去<br><br />
        str = stringReplace(str, "<([^<>]+)>", "");// 去掉<>內的字元
        str = stringReplace(str, "\\s\\s\\s*", " ");// 將多個空白變成一個空格
        str = stringReplace(str, "^\\s*", "");// 去掉頭的空白
        str = stringReplace(str, "\\s*$", "");// 去掉尾的空白
        str = stringReplace(str, " +", " ");
        return str;
    }
    
    /**
     * 除去html標籤
     * 
     * @param str
     *            源字串
     * @return 目標字串
     */
    public static String removeHTMLLable(String str) {
        str = stringReplace(str, "\\s", "");// 去掉頁面上看不到的字元
        str = stringReplace(str, "<br ?/?>", "\n");// 去<br><br />
        str = stringReplace(str, "<([^<>]+)>", "");// 去掉<>內的字元
        str = stringReplace(str, " ", " ");// 替換空格
        str = stringReplace(str, "&(\\S)(\\S?)(\\S?)(\\S?);", "");// 去<br><br />
        return str;
    }
    
    /**
     * 去掉HTML標籤之外的字串
     * 
     * @param str
     *            源字串
     * @return 目標字串
     */
    public static String removeOutHTMLLable(String str) {
        str = stringReplace(str, ">([^<>]+)<", "><");
        str = stringReplace(str, "^([^<>]+)<", "<");
        str = stringReplace(str, ">([^<>]+)$", ">");
        return str;
    }
    
    /**
     * 字串替換
     * 
     * @param str
     *            源字串
     * @param sr
     *            正則表示式樣式
     * @param sd
     *            替換文字
     * @return 結果串
     */
    public static String stringReplace(String str, String sr, String sd) {
        String regEx = sr;
        Pattern p = Pattern.compile(regEx, Pattern.CASE_INSENSITIVE);
        Matcher m = p.matcher(str);
        str = m.replaceAll(sd);
        return str;
    }
    
    /**
     * 將html的省略寫法替換成非省略寫法
     * 
     * @param str
     *            html字串
     * @param pt
     *            標籤如table
     * @return 結果串
     */
    public static String fomateToFullForm(String str, String pt) {
        String regEx = "<" + pt + "\\s+([\\S&&[^<>]]*)/>";
        Pattern p = Pattern.compile(regEx, Pattern.CASE_INSENSITIVE);
        Matcher m = p.matcher(str);
        String[] sa = null;
        String sf = "";
        String sf2 = "";
        String sf3 = "";
        for (; m.find();) {
            sa = p.split(str);
            if (sa == null) {
                break;
            }
            sf = str.substring(sa[0].length(), str.indexOf("/>", sa[0].length()));
            sf2 = sf + "></" + pt + ">";
            sf3 = str.substring(sa[0].length() + sf.length() + 2);
            str = sa[0] + sf2 + sf3;
            sa = null;
        }
        return str;
    }
    
    /**
     * 得到字串的子串位置序列
     * 
     * @param str
     *            字串
     * @param sub
     *            子串
     * @param b
     *            true子串前端,false子串後端
     * @return 字串的子串位置序列
     */
    public static int[] getSubStringPos(String str, String sub, boolean b) {
        // int[] i = new int[(new Integer((str.length()-stringReplace( str , sub
        // , "" ).length())/sub.length())).intValue()] ;
        String[] sp = null;
        int l = sub.length();
        sp = splitString(str, sub);
        if (sp == null) {
            return null;
        }
        int[] ip = new int[sp.length - 1];
        for (int i = 0; i < sp.length - 1; i++) {
            ip[i] = sp[i].length() + l;
            if (i != 0) {
                ip[i] += ip[i - 1];
            }
        }
        if (b) {
            for (int j = 0; j < ip.length; j++) {
                ip[j] = ip[j] - l;
            }
        }
        return ip;
    }
    
    /**
     * 根據正則表示式分割字串
     * 
     * @param str
     *            源字串
     * @param ms
     *            正則表示式
     * @return 目標字串組
     */
    public static String[] splitString(String str, String ms) {
        String regEx = ms;
        Pattern p = Pattern.compile(regEx, Pattern.CASE_INSENSITIVE);
        String[] sp = p.split(str);
        return sp;
    }
    
    /**
     * *************************************************************************
     * 根據正則表示式提取字串,相同的字串只返回一個
     * 
     * @param str
     *            源字串
     * @param pattern
     *            正則表示式
     * @return 目標字串資料組
     */
    
    // ★傳入一個字串，把符合pattern格式的字串放入字串陣列
    // java.util.regex是一個用正則表示式所訂製的模式來對字串進行匹配工作的類庫包
    public static String[] getStringArrayByPattern(String str, String pattern) {
        Pattern p = Pattern.compile(pattern, Pattern.CASE_INSENSITIVE);
        Matcher matcher = p.matcher(str);
        // 範型
        Set<String> result = new HashSet<String>();// 目的是：相同的字串只返回一個。。。 不重複元素
        // boolean find() 嘗試在目標字串裡查詢下一個匹配子串。
        while (matcher.find()) {
            for (int i = 0; i < matcher.groupCount(); i++) { // int groupCount()
                                                             // 返回當前查詢所獲得的匹配組的數量。
                // System.out.println(matcher.group(i));
                result.add(matcher.group(i));
                
            }
        }
        String[] resultStr = null;
        if (result.size() > 0) {
            resultStr = new String[result.size()];
            return result.toArray(resultStr);// 將Set result轉化為String[] resultStr
        }
        return resultStr;
        
    }
    
    /**
     * 得到第一個b,e之間的字串,並返回e後的子串
     * 
     * @param s
     *            源字串
     * @param b
     *            標誌開始
     * @param e
     *            標誌結束
     * @return b,e之間的字串
     */
    
    /*
     * String aaa="abcdefghijklmn"; String[] bbb=StringProcessor.midString(aaa,
     * "b","l"); System.out.println("bbb[0]:"+bbb[0]);//cdefghijk
     * System.out.println("bbb[1]:"+bbb[1]);//lmn
     * ★這個方法是得到第二個引數和第三個引數之間的字串,賦給元素0;然後把元素0代表的字串之後的,賦給元素1
     */
    
    /*
     * String aaa="abcdefgllhijklmn5465"; String[]
     * bbb=StringProcessor.midString(aaa, "b","l"); //ab cdefg llhijklmn5465 //
     * 元素0 元素1
     */
    public static String[] midString(String s, String b, String e) {
        int i = s.indexOf(b) + b.length();
        int j = s.indexOf(e, i);
        String[] sa = new String[2];
        if (i < b.length() || j < i + 1 || i > j) {
            sa[1] = s;
            sa[0] = null;
            return sa;
        } else {
            sa[0] = s.substring(i, j);
            sa[1] = s.substring(j);
            return sa;
        }
    }
    
    /**
     * 帶有前一次替代序列的正則表示式替代
     * 
     * @param s
     * @param pf
     * @param pb
     * @param start
     * @return
     */
    public static String stringReplace(String s, String pf, String pb, int start) {
        Pattern pattern_hand = Pattern.compile(pf);
        Matcher matcher_hand = pattern_hand.matcher(s);
        int gc = matcher_hand.groupCount();
        int pos = start;
        String sf1 = "";
        String sf2 = "";
        String sf3 = "";
        int if1 = 0;
        String strr = "";
        while (matcher_hand.find(pos)) {
            sf1 = matcher_hand.group();
            if1 = s.indexOf(sf1, pos);
            if (if1 >= pos) {
                strr += s.substring(pos, if1);
                pos = if1 + sf1.length();
                sf2 = pb;
                for (int i = 1; i <= gc; i++) {
                    sf3 = "\\" + i;
                    sf2 = replaceAll(sf2, sf3, matcher_hand.group(i));
                }
                strr += sf2;
            } else {
                return s;
            }
        }
        strr = s.substring(0, start) + strr;
        return strr;
    }
    
    /**
     * 存文字替換
     * 
     * @param s
     *            源字串
     * @param sf
     *            子字串
     * @param sb
     *            替換字串
     * @return 替換後的字串
     */
    public static String replaceAll(String s, String sf, String sb) {
        int i = 0, j = 0;
        int l = sf.length();
        boolean b = true;
        boolean o = true;
        String str = "";
        do {
            j = i;
            i = s.indexOf(sf, j);
            if (i > j) {
                str += s.substring(j, i);
                str += sb;
                i += l;
                o = false;
            } else {
                str += s.substring(j);
                b = false;
            }
        } while (b);
        if (o) {
            str = s;
        }
        return str;
    }
    
    /**
     * 判斷是否與給定字串樣式匹配
     * 
     * @param str
     *            字串
     * @param pattern
     *            正則表示式樣式
     * @return 是否匹配是true,否false
     */
    public static boolean isMatch(String str, String pattern) {
        Pattern pattern_hand = Pattern.compile(pattern);
        Matcher matcher_hand = pattern_hand.matcher(str);
        boolean b = matcher_hand.matches();
        return b;
    }
    
    /**
     * 擷取字串
     * 
     * @param s
     *            源字串
     * @param jmp
     *            跳過jmp
     * @param sb
     *            取在sb
     * @param se
     *            於se
     * @return 之間的字串
     */
    public static String subStringExe(String s, String jmp, String sb, String se) {
        if (isEmpty(s)) {
            return "";
        }
        int i = s.indexOf(jmp);
        if (i >= 0 && i < s.length()) {
            s = s.substring(i + 1);
        }
        i = s.indexOf(sb);
        if (i >= 0 && i < s.length()) {
            s = s.substring(i + 1);
        }
        if (se == "") {
            return s;
        } else {
            i = s.indexOf(se);
            if (i >= 0 && i < s.length()) {
                s = s.substring(i + 1);
            }
            return s;
        }
    }
    
    /**
     * 用要通過URL傳輸的內容進行編碼
     * 
     * @param 源字串
     * @return 經過編碼的內容
     */
    public static String URLEncode(String src) {
        String return_value = "";
        try {
            if (src != null) {
                return_value = URLEncoder.encode(src, "GBK");
                
            }
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            return_value = src;
        }
        
        return return_value;
    }
    
    /**
     * 換成GBK的字串
     * 
     * @param str
     * @return
     */
    public static String getGBK(String str) {
        
        return transfer(str);
    }
    
    public static String transfer(String str) {
        Pattern p = Pattern.compile("&#\\d+;");
        Matcher m = p.matcher(str);
        while (m.find()) {
            String old = m.group();
            str = str.replaceAll(old, getChar(old));
        }
        return str;
    }
    
    public static String getChar(String str) {
        String dest = str.substring(2, str.length() - 1);
        char ch = (char) Integer.parseInt(dest);
        return "" + ch;
    }
    
    /**
     * 首頁中切割字串.
     * 
     * @date 2007-09-17
     * @param str
     * @return
     */
    public static String subYhooString(String subject, int size) {
        subject = subject.substring(1, size);
        return subject;
    }
    
    public static String subYhooStringDot(String subject, int size) {
        subject = subject.substring(1, size) + "...";
        return subject;
    }
    
    /**
     * 泛型方法(通用)，把list轉換成以“,”相隔的字串 呼叫時注意型別初始化（申明型別） 如：List<Integer> intList =
     * new ArrayList<Integer>(); 呼叫方法：StringUtil.listTtoString(intList);
     * 效率：list中4條資訊，1000000次呼叫時間為850ms左右
     * 
     * @param <T>
     *            泛型
     * @param list
     *            list列表
     * @return 以“,”相隔的字串
     */
    public static <T> String listTtoString(List<T> list) {
        if (list == null || list.size() < 1)
            return "";
        Iterator<T> i = list.iterator();
        if (!i.hasNext())
            return "";
        StringBuilder sb = new StringBuilder();
        for (;;) {
            T e = i.next();
            sb.append(e);
            if (!i.hasNext())
                return sb.toString();
            sb.append(",");
        }
    }
    
    /**
     * 把整形陣列轉換成以“,”相隔的字串
     * 
     * @param a
     *            陣列a
     * @return 以“,”相隔的字串
     */
    public static String intArraytoString(int[] a) {
        if (a == null)
            return "";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "";
        StringBuilder b = new StringBuilder();
        for (int i = 0;; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.toString();
            b.append(",");
        }
    }
    
    /**
     * 判斷文字內容重複
     * 
     * @Date 2008-04-17
     */
    public static boolean isContentRepeat(String content) {
        int similarNum = 0;
        int forNum = 0;
        int subNum = 0;
        int thousandNum = 0;
        String startStr = "";
        String nextStr = "";
        boolean result = false;
        float endNum = (float) 0.0;
        if (content != null && content.length() > 0) {
            if (content.length() % 1000 > 0)
                thousandNum = (int) Math.floor(content.length() / 1000) + 1;
            else
                thousandNum = (int) Math.floor(content.length() / 1000);
            if (thousandNum < 3)
                subNum = 100 * thousandNum;
            else if (thousandNum < 6)
                subNum = 200 * thousandNum;
            else if (thousandNum < 9)
                subNum = 300 * thousandNum;
            else
                subNum = 3000;
            for (int j = 1; j < subNum; j++) {
                if (content.length() % j > 0)
                    forNum = (int) Math.floor(content.length() / j) + 1;
                else
                    forNum = (int) Math.floor(content.length() / j);
                if (result || j >= content.length())
                    break;
                else {
                    for (int m = 0; m < forNum; m++) {
                        if (m * j > content.length() || (m + 1) * j > content.length()
                                || (m + 2) * j > content.length())
                            break;
                        startStr = content.substring(m * j, (m + 1) * j);
                        nextStr = content.substring((m + 1) * j, (m + 2) * j);
                        if (startStr.equals(nextStr)) {
                            similarNum = similarNum + 1;
                            endNum = (float) similarNum / forNum;
                            if (endNum > 0.4) {
                                result = true;
                                break;
                            }
                        } else
                            similarNum = 0;
                    }
                }
            }
        }
        return result;
    }
    
    /**
     * Ascii轉為Char
     * 
     * @param asc
     * @return
     */
    public static String AsciiToChar(int asc) {
        String TempStr = "A";
        char tempchar = (char) asc;
        TempStr = String.valueOf(tempchar);
        return TempStr;
    }
    
    /**
     * 判斷是否是空字串 null和"" null返回result,否則返回字串
     * 
     * @param s
     * @return
     */
    public static String isEmpty(String s, String result) {
        if (s != null && !s.equals("")) {
            return s;
        }
        return result;
    }
    
    /**
     * 將帶有htmlcode程式碼的字元轉換成<>&'"
     * 
     * @param str
     * @return
     */
    public static String htmlcodeToSpecialchars(String str) {
        str = str.replaceAll("&", "&");
        str = str.replaceAll(""", "\"");
        str = str.replaceAll("'", "'");
        str = str.replaceAll("<", "<");
        str = str.replaceAll(">", ">");
        return str;
    }
    
    /**
     * 移除html標籤
     * 
     * @param htmlstr
     * @return
     */
    public static String removeHtmlTag(String htmlstr) {
        Pattern pat = Pattern.compile("\\s*<.*?>\\s*", Pattern.DOTALL | Pattern.MULTILINE
                | Pattern.CASE_INSENSITIVE); // \\s?[s|Sc|Cr|Ri|Ip|Pt|T]
        Matcher m = pat.matcher(htmlstr);
        String rs = m.replaceAll("");
        rs = rs.replaceAll(" ", " ");
        rs = rs.replaceAll("<", "<");
        rs = rs.replaceAll(">", ">");
        return rs;
    }
    
    /**
     * 取從指定搜尋項開始的字串，返回的值不包含搜尋項
     * 
     * @param captions
     *            例如:"www.koubei.com"
     * @param regex
     *            分隔符，例如"."
     * @return 結果字串，如：koubei.com，如未找到返回空串
     */
    public static String getStrAfterRegex(String captions, String regex) {
        if (!isEmpty(captions) && !isEmpty(regex)) {
            int pos = captions.indexOf(regex);
            if (pos != -1 && pos < captions.length() - 1) {
                return captions.substring(pos + 1);
            }
        }
        return "";
    }
    
    /**
     * 把位元組碼轉換成16進位制
     */
    public static String byte2hex(byte bytes[]) {
        StringBuffer retString = new StringBuffer();
        for (int i = 0; i < bytes.length; ++i) {
            retString.append(Integer.toHexString(0x0100 + (bytes[i] & 0x00FF)).substring(1).toUpperCase());
        }
        return retString.toString();
    }
    
    /**
     * 把16進位制轉換成位元組碼
     * 
     * @param hex
     * @return
     */
    public static byte[] hex2byte(String hex) {
        byte[] bts = new byte[hex.length() / 2];
        for (int i = 0; i < bts.length; i++) {
            bts[i] = (byte) Integer.parseInt(hex.substring(2 * i, 2 * i + 2), 16);
        }
        return bts;
    }
    
    /**
     * 轉換數字為固定長度的字串
     * 
     * @param length
     *            希望返回的字串長度
     * @param data
     *            傳入的數值
     * @return
     */
    public static String getStringByInt(int length, String data) {
        String s_data = "";
        int datalength = data.length();
        if (length > 0 && length >= datalength) {
            for (int i = 0; i < length - datalength; i++) {
                s_data += "0";
            }
            s_data += data;
        }
        
        return s_data;
    }
    
    /**
     * 判斷是否位數字,並可為空
     * 
     * @param src
     * @return
     */
    public static boolean isNumericAndCanNull(String src) {
        Pattern numericPattern = Pattern.compile("^[0-9]+$");
        if (src == null || src.equals(""))
            return true;
        boolean return_value = false;
        if (src != null && src.length() > 0) {
            Matcher m = numericPattern.matcher(src);
            if (m.find()) {
                return_value = true;
            }
        }
        return return_value;
    }
    
    /**
     * @param src
     * @return
     */
    public static boolean isFloatAndCanNull(String src) {
        Pattern numericPattern = Pattern.compile("^(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*))$");
        if (src == null || src.equals(""))
            return true;
        boolean return_value = false;
        if (src != null && src.length() > 0) {
            Matcher m = numericPattern.matcher(src);
            if (m.find()) {
                return_value = true;
            }
        }
        return return_value;
    }
    
    public static boolean isNotEmpty(String str) {
        if (str != null && !str.equals(""))
            return true;
        else
            return false;
    }
    
    public static boolean isDate(String date) {
        String regEx = "\\d{4}-\\d{2}-\\d{2}\\s\\d{2}:\\d{2}:\\d{2}";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(date);
        boolean result = m.find();
        return result;
    }
    
    public static boolean isFormatDate(String date, String regEx) {
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(date);
        boolean result = m.find();
        return result;
    }
    
    /**
     * 根據指定整型list 組裝成為一個字串
     * 
     * @param src
     * @return
     */
    public static String listToString(List<Integer> list) {
        String str = "";
        if (list != null && list.size() > 0) {
            for (int id : list) {
                str = str + id + ",";
            }
            if (!"".equals(str) && str.length() > 0)
                str = str.substring(0, str.length() - 1);
        }
        return str;
    }
    
    /**
     * 頁面的非法字元檢查
     * 
     * @param str
     * @return
     */
    public static String replaceStr(String str) {
        if (str != null && str.length() > 0) {
            str = str.replaceAll("~", ",");
            str = str.replaceAll(" ", ",");
            str = str.replaceAll("　", ",");
            str = str.replaceAll(" ", ",");
            str = str.replaceAll("`", ",");
            str = str.replaceAll("!", ",");
            str = str.replaceAll("@", ",");
            str = str.replaceAll("#", ",");
            str = str.replaceAll("\\$", ",");
            str = str.replaceAll("%", ",");
            str = str.replaceAll("\\^", ",");
            str = str.replaceAll("&", ",");
            str = str.replaceAll("\\*", ",");
            str = str.replaceAll("\\(", ",");
            str = str.replaceAll("\\)", ",");
            str = str.replaceAll("-", ",");
            str = str.replaceAll("_", ",");
            str = str.replaceAll("=", ",");
            str = str.replaceAll("\\+", ",");
            str = str.replaceAll("\\{", ",");
            str = str.replaceAll("\\[", ",");
            str = str.replaceAll("\\}", ",");
            str = str.replaceAll("\\]", ",");
            str = str.replaceAll("\\|", ",");
            str = str.replaceAll("\\\\", ",");
            str = str.replaceAll(";", ",");
            str = str.replaceAll(":", ",");
            str = str.replaceAll("'", ",");
            str = str.replaceAll("\\\"", ",");
            str = str.replaceAll("<", ",");
            str = str.replaceAll(">", ",");
            str = str.replaceAll("\\.", ",");
            str = str.replaceAll("\\?", ",");
            str = str.replaceAll("/", ",");
            str = str.replaceAll("～", ",");
            str = str.replaceAll("`", ",");
            str = str.replaceAll("！", ",");
            str = str.replaceAll("＠", ",");
            str = str.replaceAll("＃", ",");
            str = str.replaceAll("＄", ",");
            str = str.replaceAll("％", ",");
            str = str.replaceAll("︿", ",");
            str = str.replaceAll("＆", ",");
            str = str.replaceAll("×", ",");
            str = str.replaceAll("（", ",");
            str = str.replaceAll("）", ",");
            str = str.replaceAll("－", ",");
            str = str.replaceAll("＿", ",");
            str = str.replaceAll("＋", ",");
            str = str.replaceAll("＝", ",");
            str = str.replaceAll("｛", ",");
            str = str.replaceAll("［", ",");
            str = str.replaceAll("｝", ",");
            str = str.replaceAll("］", ",");
            str = str.replaceAll("｜", ",");
            str = str.replaceAll("＼", ",");
            str = str.replaceAll("：", ",");
            str = str.replaceAll("；", ",");
            str = str.replaceAll("＂", ",");
            str = str.replaceAll("＇", ",");
            str = str.replaceAll("＜", ",");
            str = str.replaceAll("，", ",");
            str = str.replaceAll("＞", ",");
            str = str.replaceAll("．", ",");
            str = str.replaceAll("？", ",");
            str = str.replaceAll("／", ",");
            str = str.replaceAll("·", ",");
            str = str.replaceAll("￥", ",");
            str = str.replaceAll("……", ",");
            str = str.replaceAll("（", ",");
            str = str.replaceAll("）", ",");
            str = str.replaceAll("——", ",");
            str = str.replaceAll("-", ",");
            str = str.replaceAll("【", ",");
            str = str.replaceAll("】", ",");
            str = str.replaceAll("、", ",");
            str = str.replaceAll("”", ",");
            str = str.replaceAll("’", ",");
            str = str.replaceAll("《", ",");
            str = str.replaceAll("》", ",");
            str = str.replaceAll("“", ",");
            str = str.replaceAll("。", ",");
        }
        return str;
    }
    
    /**
     * 全形字元變半形字元
     * 
     * @param str
     * @return
     */
    public static String full2Half(String str) {
        if (str == null || "".equals(str))
            return "";
        StringBuffer sb = new StringBuffer();
        
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            
            if (c >= 65281 && c < 65373)
                sb.append((char) (c - 65248));
            else
                sb.append(str.charAt(i));
        }
        
        return sb.toString();
        
    }
    
    /**
     * 全形括號轉為半形
     * 
     * @param str
     * @return
     */
    public static String replaceBracketStr(String str) {
        if (str != null && str.length() > 0) {
            str = str.replaceAll("（", "(");
            str = str.replaceAll("）", ")");
        }
        return str;
    }
    
    /**
     * 分割字元，從開始到第一個split字串為止
     * 
     * @param src
     *            源字串
     * @param split
     *            截止字串
     * @return
     */
    public static String subStr(String src, String split) {
        if (!isEmpty(src)) {
            int index = src.indexOf(split);
            if (index >= 0) {
                return src.substring(0, index);
            }
        }
        return src;
    }
    
    /**
     * 取url裡的keyword（可選擇引數）引數，用於整站搜尋整合
     * 
     * @param params
     * @param qString
     * @return
     */
    public static String getKeyWord(String params, String qString) {
        String keyWord = "";
        if (qString != null) {
            String param = params + "=";
            int i = qString.indexOf(param);
            if (i != -1) {
                int j = qString.indexOf("&", i + param.length());
                if (j > 0) {
                    keyWord = qString.substring(i + param.length(), j);
                }
            }
        }
        return keyWord;
    }
    
    /**
     * 解析字串返回map鍵值對(例：a=1&b=2 => a=1,b=2)
     * 
     * @param query
     *            源引數字串
     * @param split1
     *            鍵值對之間的分隔符（例：&）
     * @param split2
     *            key與value之間的分隔符（例：=）
     * @param dupLink
     *            重複引數名的引數值之間的連線符，連線後的字串作為該引數的引數值，可為null
     *            null：不允許重複引數名出現，則靠後的引數值會覆蓋掉靠前的引數值。
     * @return map
     */
    @SuppressWarnings("unchecked")
    public static Map<String, String> parseQuery(String query, char split1, char split2,
            String dupLink) {
        if (!isEmpty(query) && query.indexOf(split2) > 0) {
            Map<String, String> result = new HashMap();
            
            String name = null;
            String value = null;
            String tempValue = "";
            int len = query.length();
            for (int i = 0; i < len; i++) {
                char c = query.charAt(i);
                if (c == split2) {
                    value = "";
                } else if (c == split1) {
                    if (!isEmpty(name) && value != null) {
                        if (dupLink != null) {
                            tempValue = result.get(name);
                            if (tempValue != null) {
                                value += dupLink + tempValue;
                            }
                        }
                        result.put(name, value);
                    }
                    name = null;
                    value = null;
                } else if (value != null) {
                    value += c;
                } else {
                    name = (name != null) ? (name + c) : "" + c;
                }
            }
            
            if (!isEmpty(name) && value != null) {
                if (dupLink != null) {
                    tempValue = result.get(name);
                    if (tempValue != null) {
                        value += dupLink + tempValue;
                    }
                }
                result.put(name, value);
            }
            
            return result;
        }
        return null;
    }
    
    /**
     * 將list 用傳入的分隔符組裝為String
     * 
     * @param list
     * @param slipStr
     * @return String
     */
    @SuppressWarnings("unchecked")
    public static String listToStringSlipStr(List list, String slipStr) {
        StringBuffer returnStr = new StringBuffer();
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                returnStr.append(list.get(i)).append(slipStr);
            }
        }
        if (returnStr.toString().length() > 0)
            return returnStr.toString().substring(0, returnStr.toString().lastIndexOf(slipStr));
        else
            return "";
    }
    
    /**
     * 獲取從start開始用*替換len個長度後的字串
     * 
     * @param str
     *            要替換的字串
     * @param start
     *            開始位置
     * @param len
     *            長度
     * @return 替換後的字串
     */
    public static String getMaskStr(String str, int start, int len) {
        if (StringUtil.isEmpty(str)) {
            return str;
        }
        if (str.length() < start) {
            return str;
        }
        
        // 獲取*之前的字串
        String ret = str.substring(0, start);
        
        // 獲取最多能打的*個數
        int strLen = str.length();
        if (strLen < start + len) {
            len = strLen - start;
        }
        
        // 替換成*
        for (int i = 0; i < len; i++) {
            ret += "*";
        }
        
        // 加上*之後的字串
        if (strLen > start + len) {
            ret += str.substring(start + len);
        }
        
        return ret;
    }
    
    /**
     * 根據傳入的分割符號,把傳入的字串分割為List字串
     * 
     * @param slipStr
     *            分隔的字串
     * @param src
     *            字串
     * @return 列表
     */
    public static List<String> stringToStringListBySlipStr(String slipStr, String src) {
        
        if (src == null)
            return null;
        List<String> list = new ArrayList<String>();
        String[] result = src.split(slipStr);
        for (int i = 0; i < result.length; i++) {
            list.add(result[i]);
        }
        return list;
    }
    
    /**
     * 擷取字串
     * 
     * @param str
     *            原始字串
     * @param len
     *            要擷取的長度
     * @param tail
     *            結束加上的字尾
     * @return 擷取後的字串
     */
    public static String getHtmlSubString(String str, int len, String tail) {
        if (str == null || str.length() <= len) {
            return str;
        }
        int length = str.length();
        char c = ' ';
        String tag = null;
        String name = null;
        int size = 0;
        String result = "";
        boolean isTag = false;
        List<String> tags = new ArrayList<String>();
        int i = 0;
        for (int end = 0, spanEnd = 0; i < length && len > 0; i++) {
            c = str.charAt(i);
            if (c == '<') {
                end = str.indexOf('>', i);
            }
            
            if (end > 0) {
                // 擷取標籤
                tag = str.substring(i, end + 1);
                int n = tag.length();
                if (tag.endsWith("/>")) {
                    isTag = true;
                } else if (tag.startsWith("</")) { // 結束符
                    name = tag.substring(2, end - i);
                    size = tags.size() - 1;
                    // 堆疊取出html開始標籤
                    if (size >= 0 && name.equals(tags.get(size))) {
                        isTag = true;
                        tags.remove(size);
                    }
                } else { // 開始符
                    spanEnd = tag.indexOf(' ', 0);
                    spanEnd = spanEnd > 0 ? spanEnd : n;
                    name = tag.substring(1, spanEnd);
                    if (name.trim().length() > 0) {
                        // 如果有結束符則為html標籤
                        spanEnd = str.indexOf("</" + name + ">", end);
                        if (spanEnd > 0) {
                            isTag = true;
                            tags.add(name);
                        }
                    }
                }
                // 非html標籤字元
                if (!isTag) {
                    if (n >= len) {
                        result += tag.substring(0, len);
                        break;
                    } else {
                        len -= n;
                    }
                }
                
                result += tag;
                isTag = false;
                i = end;
                end = 0;
            } else { // 非html標籤字元
                len--;
                result += c;
            }
        }
        // 新增未結束的html標籤
        for (String endTag : tags) {
            result += "</" + endTag + ">";
        }
        if (i < length) {
            result += tail;
        }
        return result;
    }
    
    
}