stringutil

private static final String allChar = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

    private static final String letterChar = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

    private static final String digitChar = "0123456789";

    /**
     * 判别字符串是否为null或者没有内容
     *
     * @param inStr 被判断的输入参数
     * @return 布尔值：true=表示输入字符串为null或者没有内容 false=表示输入字符串不为null或者有内容
     */
    public static boolean zero(String inStr) {
        return ((null == inStr) || (inStr.length() <= 0));
    }

    /**
     * 判断字符串是否为null或没有内容或全部为空格。
     *
     * @param inStr 被判断的输入参数
     * @return 布尔值：true=表示输入字符串为null或没有内容或全部为空格 false=表示输入字符串不为null或有内容或全部不为空格
     */
    public static boolean empty(String inStr) {
        return (zero(inStr) || (inStr.trim().equals("")));
    }

    /**
     * 判断字符串是否为null或没有内容或全部为空格或为null字符串。
     *
     * @param inStr 被判断的输入参数
     * @return 布尔值：true=表示输入字符串为null或没有内容或全部为空格 false=表示输入字符串不为null或有内容或全部不为空格
     */
    public static boolean emptyornull(String inStr) {
        return empty(inStr) || equalsIgnoreCase(inStr, "null");
    }

    /**
     * 在str为null或者没有内容的情况下，返回空串；否则返回输入参数。
     *
     * @param inStr 被判断的输入参数
     * @return 字符串="" 表示输入字符串为null或者没有内容 字符串!="" 表示输入字符串有内容
     */
    public static String toZeroSafe(String inStr) {
        if(zero(inStr)) {
            return "";
        }
        return inStr;
    }

    /**
     * 在inStr为null或者没有内容的情况下，返回def；否则返回str
     *
     * @param inStr 被判断的输入参数
     * @param def inStr为null或者没有内容的情况下，需要返回的字符串
     * @return 字符串=def 表示输入字符串为null或者没有内容 字符串=inStr 表示输入字符串有内容
     */
    public static String toZeroSafe(String inStr, String def) {
        if(zero(inStr)) {
            return def;
        }
        return inStr;
    }

    /**
     * 在str为null或者没有内容，或者全部为空格的情况下，返回空串；否则返回str
     *
     * @param inStr 被判断的输入参数
     * @return 字符串="" 表示输入字符串为null或者没有内容或者全部为空格 字符串!="" 表示输入字符串有内容
     */
    public static String toEmptySafe(String inStr) {
        if(empty(inStr)) {
            return "";
        }
        return inStr;
    }

    /**
     * 在str为null或者没有内容，或者全部为空格的情况下，返回def；否则返回str
     *
     * @param inStr 被判断的输入参数
     * @param def inStr为null或者没有内容或者全部为空格的情况下，需要返回的字符串
     * @return 字符串=def 表示输入字符串为null或者没有内容或者全部为空格 字符串=inStr 表示输入字符串有内容
     */
    public static String toEmptySafe(String inStr, String def) {
        if(empty(inStr)) {
            return def;
        }
        return inStr;
    }

    /**
     * 去掉输入字符串首尾空格
     *
     * @param inStr 输入字符串
     * @return 首尾无空格的字符串
     */
    public static String trim(String inStr) {
        if(empty(inStr)) {
            return inStr;
        }
        return inStr.trim();
    }

    /**
     * 判断字符串是否内容相同
     *
     * @param s1 第1个输入字符串
     * @param s2 第2个输入字符串
     * @return 布尔值=true：两个字符串相等 =false:两个字符串不相等
     */
    public static boolean equals(String s1, String s2) {
        if(s1 == s2)
            return true;
        if(null == s1)
            return false;
        return s1.equals(s2);
    }

    /**
     * 判断字符串是否内容相同，不区分大小写
     *
     * @param s1 第1个输入字符串
     * @param s2 第2个输入字符串
     * @return 布尔值=true：两个字符串相等 =false:两个字符串不相等
     */
    public static boolean equalsIgnoreCase(String s1, String s2) {
        if(null == s1) {
            return false;
        }
        return s1.equalsIgnoreCase(s2);
    }

    /**
     * 把字符数组转换成字符串
     *
     * @param array 字符数组
     * @return 转换后的字符串
     */
    public static String toString(char[] array) {
        return String.valueOf(array);
    }

    /**
     * 在字符串中，用新的字符串替换指定的字符
     *
     * @param src 需要替换的字符串
     * @param charOld 被替换的字符
     * @param strNew 用于替换的字符串
     * @return 已经替换好的字符串
     */
    public static String replace(String src, char charOld, String strNew) {
        if(null == src) {
            return src;
        }
        if(null == strNew) {
            return src;
        }

        StringBuilder buf = new StringBuilder();
        for(int i = 0, n = src.length(); i < n; i++) {
            char c = src.charAt(i);
            if(c == charOld) {
                buf.append(strNew);
            }else {
                buf.append(c);
            }
        }
        return buf.toString();
    }

    /**
     * 把字符串的第一个字符变为大写
     *
     * @param s 输入字符串
     * @return 返回第一个字符是大写的字符串
     */
    public static String upperFirst(String s) {
        String str = null;
        if(null != s) {
            if(s.length() == 1) {
                str = s.toUpperCase();
            }else {
                str = s.substring(0, 1).toUpperCase() + s.substring(1);
            }
        }
        return str;
    }

    /**
     * 把字符对象第一个字符变为大写
     *
     * @param sb 字符对象
     */
    public static void upperFirst(StringBuilder sb) {
        if((null != sb) && (sb.length() > 0)) {
            sb.setCharAt(0, Character.toUpperCase(sb.charAt(0)));
        }
    }

    /**
     * 把字符串的第一个字符变为小写
     *
     * @param s 输入的字符串
     * @return 返回的第一个字符是小写的字符串
     */
    public static String lowerFirst(String s) {
        String str = null;
        if(null != s) {
            if(s.length() == 1) {
                str = s.toLowerCase();
            }else {
                str = s.substring(0, 1).toLowerCase() + s.substring(1);
            }
        }
        return str;
    }

    /**
     * 把字符对象的第一个字符变为小写
     *
     * @param sb 输入的字符对象
     */
    public static void lowerFirst(StringBuilder sb) {
        if((null != sb) && (sb.length() > 0)) {
            sb.setCharAt(0, Character.toLowerCase(sb.charAt(0)));
        }
    }

    /**
     * 根据指定的delima标志获取输入字符串的后缀
     *
     * @param str 输入字符串
     * @param delima 指定的标志,一般是一个字符，如“.”
     * @return 输入字符串子的后缀
     */
    public static String getLastSuffix(String str, String delima) {
        if(zero(delima)) {
            return str;
        }

        String suffix = "";
        if(!zero(str)) {
            int index = str.lastIndexOf(delima);
            if(index >= 0) {
                suffix = str.substring(index + delima.length());
            }else {
                suffix = str;
            }
        }
        return suffix;
    }

    /**
     * 根据指定的delima标志获取输入字符串的前缀
     *
     * @param src 输入字符串
     * @param delima 指定的标志,一般是一个字符，如“.”
     * @return 输入字符串的前缀
     */
    public static String getLastPrefix(String src, String delima) {
        if(zero(delima)) {
            return src;
        }

        String prefix = "";
        if(!zero(src)) {
            int index = src.lastIndexOf(delima);
            if(index >= 0) {
                prefix = src.substring(0, index);
            }
        }
        return prefix;
    }

    /**
     * 判断输入字符串是否包含指定的字符串
     *
     * @param str 输入字符串
     * @param searchStr 指定是否包含的字符串
     * @return =true:包含指定的字符串 =false:不包含指定的字符串
     */
    public static boolean contains(String str, String searchStr) {
        if(str == null || searchStr == null) {
            return false;
        }
        if(searchStr.length() == 0) // ""空串不认为被包含。String.indexOf()认为空串被包含
        {
            return false;
        }else {
            return str.indexOf(searchStr) >= 0;
        }
    }

    /**
     * 将指定的字符串按特殊字符分割成集合.<br>
     *
     *@param inStr 分割字符串=
     *@param delim 分割特殊字符 一般为",-:"
     *@return 字符串集合
     */
    public static List<String> getListByStr(String inStr, String delim) {
        List<String> strList = new ArrayList<String>();
        if(empty(inStr) || empty(delim)) {
            return strList;
        }
        String[] arrStr = inStr.split(delim);
        for(String temp: arrStr) {
            strList.add(temp);
        }
        return strList;
    }

    /**
     * 将指定的字符串按特殊字符分割成数组.<br>
     *
     *@param inStr 分割字符串
     *@param delim 分割特殊字符 一般为",-:"
     *@return 字符串数组
     */
    public static String[] split(String inStr, String delim) {
        if(empty(inStr) || empty(delim)) {
            return new String[0];
        }
        return inStr.split(delim);
    }

    /**
     * 将集合转换为字符串，以特殊符号分割.<br>
     *
     *@param inList 集合
     *@param delim 分割特殊字符 一般为",-:"
     *@return 转换后的字符串
     */
    public static String toStringByList(List<String> inList, String delim) {
        String returnStr = "";
        if(null == inList || inList.size() == 0 || empty(delim)) {
            return returnStr;
        }
        for(int i = 0; i < inList.size(); i++) {
            if(i != 0) {
                returnStr += delim;
            }
            returnStr += inList.get(i);
        }
        return returnStr;
    }

    /**
     * 将集合转换为字符串，以","符号分割.<br>
     *
     *@param inList 集合
     *@return 转换后的字符串
     */
    public static String toStringByList(List<String> inList) {
        return toStringByList(inList, ",");
    }

    /**
     * 将数组转换为字符串，以特殊符号分割.<br>
     *
     *@param inArray 数组
     *@param delim 分割特殊字符 一般为",-:"
     *@return 转换后的字符串
     */
    public static String toStringByArray(String[] inArray, String delim) {
        String returnStr = "";
        if(null == inArray || inArray.length == 0 || empty(delim)) {
            return returnStr;
        }
        for(int i = 0; i < inArray.length; i++) {
            if(i != 0) {
                returnStr += delim;
            }
            returnStr += inArray[i];
        }
        return returnStr;
    }

    /**
     * 将数组转换为字符串，以","符号分割.<br>
     *
     *@param inArray 数组
     *@return 转换后的字符串
     */
    public static String toStringByArray(String[] inArray) {
        return toStringByArray(inArray, ",");
    }

    /**
     * 统计字符串的特殊字符串出现的次数.<br>
     *
     *@param inStr 字符串
     *@param countStr 特殊字符串
     *@return 总次数
     */
    public static int countStrNumber(String inStr, String countStr) {
        int count = 0;
        int startIndex = 0;
        while (true) {
            int index = inStr.indexOf(countStr, startIndex);
            if(index == -1) {
                break;
            }
            count++;
            startIndex = index + countStr.length();
        }
        return count;
    }

    /**
     * 返回一个定长的随机字符串 (只包含数字)
     *
     * @param length 随机字符串长度
     * @return 随机字符串
     */
    public static String generateDigitString(int length) {
        StringBuilder sb = new StringBuilder();
        Random random = new Random();
        for(int i = 0; i < length; i++) {
            sb.append(digitChar.charAt(random.nextInt(digitChar.length())));
        }
        return sb.toString();
    }

    /**
     * 返回一个定长的随机字符串(只包含大小写字母、数字)
     *
     * @param length 随机字符串长度
     * @return 随机字符串
     */
    public static String generateString(int length) {
        StringBuilder sb = new StringBuilder();
        Random random = new Random();
        for(int i = 0; i < length; i++) {
            sb.append(allChar.charAt(random.nextInt(allChar.length())));
        }
        return sb.toString();
    }

    /**
     * 返回一个定长的随机纯字母字符串(只包含大小写字母)
     *
     * @param length 随机字符串长度
     * @return 随机字符串
     */
    public static String generateMixString(int length) {
        StringBuilder sb = new StringBuilder();
        Random random = new Random();
        for(int i = 0; i < length; i++) {
            sb.append(allChar.charAt(random.nextInt(letterChar.length())));
        }
        return sb.toString();
    }

    /**
     * 返回一个定长的随机纯小写字母字符串(只包含小写字母)
     *
     * @param length 随机字符串长度
     * @return 随机字符串
     */
    public static String generateLowerString(int length) {
        return generateMixString(length).toLowerCase();
    }

    /**
     * 返回一个定长的随机纯大写字母字符串(只包含大写字母)
     *
     * @param length 随机字符串长度
     * @return 随机字符串
     */
    public static String generateUpperString(int length) {
        return generateMixString(length).toUpperCase();
    }