String工具类

package com.huawei.bfm.common.util;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang.builder.ToStringBuilder;

/**
 *  字符串处理通用工具类
 * 
 * @author tjw
 * @date [Nov 29, 2012]
 * @version [NGSDP LB5213]
 */
public final class StringUtils
{
    /** 空字符串 */
    public static final String EMPTY = "";
    
    // SQL关键字,匹配所有字符
    private static final String SQL_KEYWORD_STRING = "%";
    
    // SQL关键字,匹配单个字符
    private static final String SQL_KEYWORD_CHAR = "_";
    
    // SQL关键字,转义符
    private static final String SQL_KEYWORD_ESCAPE = "\";
    
    // 默认join 分割符
    private static final String DEFULT_JOIN_SEPARATOR = ",";
    
    // 默认封装 标示符
    private static final String DEFULT_WRAP_FLAG = "'";
    
    private StringUtils()
    {
    }
    
    /**
     * 截取目标字符串后面的字符串,以第一个开始截取
     * 
     * @param str
     *            待处理字符串
     * @param separator
     *            分隔符号
     * @return 处理后的字符串
     */
    public static String substringAfter(String str, String separator)
    {
        if (contains(str, separator))
        {
            return org.apache.commons.lang.StringUtils.substringAfter(str, separator);
        }
        return str;
    }
    
    /**
     * 截取目标字符串后面的字符串,以最后一个开始截取
     * 
     * @param str
     *            待处理字符串
     * @param separator
     *            分隔符号
     * @return 处理后的字符串
     */
    public static String substringAfterLast(String str, String separator)
    {
        if (contains(str, separator))
        {
            return org.apache.commons.lang.StringUtils.substringAfterLast(str, separator);
        }
        return str;
    }
    
    /**
     * 去除字符串前缀
     * 
     * @param str
     *            待处理字符串
     * @param prefix
     *            前缀
     * @return 处理完的字符串
     */
    public static String removePrefix(String str, String prefix)
    {
        if (isNotBlank(str, prefix))
        {
            if (str.startsWith(prefix))
            {
                return str.substring(prefix.length());
            }
        }
        return str;
    }
    
    /**
     * 添加字符串前缀
     * 
     * @param str
     *            待处理字符串
     * @param prefix
     *            前缀
     * @return 处理完的字符串
     */
    public static String appendPrefix(String str, String prefix)
    {
        if (isNotBlank(str, prefix))
        {
            if (!str.startsWith(prefix))
            {
                return prefix + str;
            }
        }
        return str;
    }
    
    /**
     * 去除字符串后缀
     * 
     * @param str
     *            待处理字符串
     * @param subfix
     *            后缀
     * @return 处理完的字符串
     */
    public static String removeSubfix(String str, String subfix)
    {
        if (isNotBlank(str, subfix))
        {
            if (str.endsWith(subfix))
            {
                return str.substring(0, str.length() - subfix.length());
            }
        }
        return str;
    }
    
    /**
     * 添加字符串后缀
     * 
     * @param str
     *            待处理字符串
     * @param subfix
     *            后缀
     * @return 处理完的字符串
     */
    public static String appendSubfix(String str, String subfix)
    {
        if (isNotBlank(str, subfix))
        {
            if (!str.endsWith(subfix))
            {
                return str + subfix;
            }
        }
        return str;
    }
    
    /**
     * 首字母转换成大写
     * 
     * @param str
     *            待转换字符串
     * @return 转换后字符串
     */
    public static String capitalize(String str)
    {
        return org.apache.commons.lang.StringUtils.capitalize(str);
    }
    
    /**
     * 目标字符串是否包含字串
     * 
     * @param str
     *            目标字符串
     * @param searchStr
     *            子字符串
     * @return 目标字符串是否包含字串
     */
    public static boolean contains(String str, String searchStr)
    {
        return org.apache.commons.lang.StringUtils.contains(str, searchStr);
    }
    
    /**
     * 默认字符串
     * 
     * 如果目标字符串为 null 返回 空串，否则返回原始字符串
     * 
     * @param str
     *            目标字符串
     * @return 默认字符串
     */
    public static String defaultString(String str)
    {
        return org.apache.commons.lang.StringUtils.defaultString(str);
    }
    
    /**
     * 默认字符串
     * 
     * 如果目标字符串为 null 返回 空串，否则返回原始字符串
     * 
     * @param str
     *            目标字符串
     * @param defaultStr
     *            默认字符串
     * @return 默认字符串
     */
    public static String defaultString(String str, String defaultStr)
    {
        return org.apache.commons.lang.StringUtils.defaultString(str, defaultStr);
    }
    
    /**
     * 字符串比对是否相同,
     * 
     * @param str
     *            待比较字符串
     * @param strs
     *            待比较字符串数组 ，任何一个字符串与目标字符串匹配成功则匹配成功
     * @return 比较结果
     */
    public static boolean equals(String str, String... strs)
    {
        
        if (ArrayUtils.isNotEmpty(strs))
        {
            for (String s : strs)
            {
                if (org.apache.commons.lang.StringUtils.equals(s, str))
                {
                    return true;
                }
            }
            return false;
        }
        else
        {
            return null == str;
        }
        
    }
    
    /**
     * SQL编码
     * 
     * <pre>
     * 将  _ % 等特殊字符前补加转意符,
     * </pre>
     * 
     * @param str
     *            未编码字符串
     * @return 编码后字符串
     */
    public static String escapeSql(String str)
    {
        if (isNotBlank(str))
        {
            str = str.replace(SQL_KEYWORD_ESCAPE, SQL_KEYWORD_ESCAPE + SQL_KEYWORD_ESCAPE);
            str = str.replace(SQL_KEYWORD_CHAR, SQL_KEYWORD_ESCAPE + SQL_KEYWORD_CHAR);
            str = str.replace(SQL_KEYWORD_STRING, SQL_KEYWORD_ESCAPE + SQL_KEYWORD_STRING);
            
        }
        return str;
    }
    
    /**
     * 获取模糊查询字符串
     * 
     * <pre>
     * 字符串前后添加 % 符号
     * </pre>
     * 
     * @param str
     *            待模糊查询字符串
     * @return 拼接相关模糊查询标识的字符串
     */
    public static String getFuzzyString(String str)
    {
        if (isNotBlank(str))
        {
            str = SQL_KEYWORD_STRING + str + SQL_KEYWORD_STRING;
        }
        return str;
    }
    
    /**
     * 获取模糊查询字符串,特殊字符进行转义
     * 
     * 
     * <pre>
     * 1、将  _ % 等特殊字符前补加转意符,
     * 2、字符串前后添加 % 符号
     * </pre>
     * 
     * @param str
     *            待模糊查询字符串
     * @return 拼接相关模糊查询标识的字符串
     */
    public static String getFuzzyStringWithEscape(String str)
    {
        if (isNotBlank(str))
        {
            return getFuzzyString(escapeSql(str));
        }
        return null;
    }
    
    /**
     * 获取被检索字符串在目标字符串中的索引的位置
     * 
     * @param str
     *            目标字符串
     * @param searchChars
     *            被检索字符串
     * @return 索引的位置
     */
    public static int indexOfAny(String str, String searchChars)
    {
        return org.apache.commons.lang.StringUtils.indexOfAny(str, searchChars);
    }
    
    /**
     * 获取被检索字符串在目标字符串中的索引的位置
     * 
     * @param str
     *            目标字符串
     * @param searchChars
     *            被检索字符串
     * @return 索引的位置
     */
    public static int indexOfAny(String str, String[] searchChars)
    {
        return org.apache.commons.lang.StringUtils.indexOfAny(str, searchChars);
    }
    
    /**
     * 是否为空
     * 
     * @param str
     *            待校验字符串
     * @return 是否为空
     */
    public static boolean isBlank(String str)
    {
        return org.apache.commons.lang.StringUtils.isBlank(str);
    }
    
    /**
     * 判断字符串指定范围的字符是否全部是数字。
     * 
     * @param str
     *            输入的字符串
     * @param begin
     *            起始下标，包括这个字符
     * @param end
     *            结束下标，不包括这个字符
     * @return 如果范围内的字符都是数字返回true，否则返回false
     */
    public static boolean isDigitInRange(String str, int begin, int end)
    {
        if (isBlank(str))
        {
            return false;
        }
        if (begin < 0 || end < 0 || begin >= end)
        {
            return false;
        }
        if (str.length() <= end)
        {
            return false;
        }
        for (int i = begin; i < end; i++)
        {
            if (!Character.isDigit(str.charAt(i)))
            {
                return false;
            }
        }
        return true;
    }
    
    /**
     * 是否为空
     * 
     * @param str
     *            待校验字符串
     * @return 是否为空
     */
    public static boolean isEmpty(String str)
    {
        return org.apache.commons.lang.StringUtils.isEmpty(str);
    }
    
    /**
     * 是否非空
     * 
     * 任何一个字符串为空,将范围false
     * 
     * @param strs
     *            待校验字符串
     * @return 是否非空
     */
    public static boolean isNotBlank(String... strs)
    {
        if (null == strs)
        {
            return false;
        }
        
        for (String str : strs)
        {
            if (!org.apache.commons.lang.StringUtils.isNotBlank(str))
            {
                return false;
            }
        }
        return true;
    }
    
    /**
     * 是否非空
     * 
     * 任何一个字符串为空,将范围false
     * 
     * @param strs
     *            待校验字符串
     * @return 是否非空
     */
    public static boolean isNotEmpty(String... strs)
    {
        if (null == strs)
        {
            return false;
        }
        for (String str : strs)
        {
            if (!org.apache.commons.lang.StringUtils.isNotEmpty(str))
            {
                return false;
            }
        }
        return true;
    }
    
    /**
     * 是否是数字
     * 
     * @param str
     *            目标字符串
     * @return 是否是数字
     */
    public static boolean isNumeric(String str)
    {
        return org.apache.commons.lang.StringUtils.isNumeric(str);
    }
    
    /**
     * 使用 , 拼接集合
     * 
     * @param col
     *            待拼接集合对象
     * @return 拼接后的字符串
     */
    public static String join(Collection<?> col)
    {
        return join(col, DEFULT_JOIN_SEPARATOR);
    }
    
    /**
     * 拼接集合数据
     * 
     * @param col
     *            待拼接集合
     * @param separator
     *            分隔符
     * @return 拼接后的集合数据
     */
    public static String join(Collection<?> col, String separator)
    {
        return org.apache.commons.lang.StringUtils.join(col, separator);
    }
    
    /**
     * 拼接集合数据
     * 
     * @param strs
     *            待拼接集合
     * @param separator
     *            分隔符
     * @return 拼接后的集合数据
     */
    public static String join(Object[] strs, String separator)
    {
        return org.apache.commons.lang.StringUtils.join(strs, separator);
    }
    
    /**
     * 左补齐字符串
     * 
     * @param str
     *            待补齐字符串
     * @param size
     *            字符串长度
     * @param padChar
     *            补齐字符
     * @return 补齐后字符串
     */
    public static String leftPad(String str, int size, char padChar)
    {
        return org.apache.commons.lang.StringUtils.leftPad(str, size, padChar);
    }
    
    /**
     * 左补齐字符串
     * 
     * @param str
     *            待补齐字符串
     * @param size
     *            字符串长度
     * @param padStr
     *            补齐字符
     * @return 补齐后字符串
     */
    public static String leftPad(String str, int size, String padStr)
    {
        return org.apache.commons.lang.StringUtils.leftPad(str, size, padStr);
    }
    
    /**
     * 转换成小写字母
     * 
     * @param str
     *            目标字符串
     * @return 转换成小写字母
     */
    public static String lowerCase(String str)
    {
        return org.apache.commons.lang.StringUtils.lowerCase(str);
    }
    
    /**
     * 分割字符串
     * 
     * @param str
     *            目标字符串
     * @param separator
     *            分隔符
     * @return 分割后的集合数据
     */
    public static String[] split(String str, char separator)
    {
        return org.apache.commons.lang.StringUtils.split(str, separator);
    }
    
    /**
     * 分割字符串
     * 
     * @param str
     *            目标字符串
     * @return 分割后的集合数据
     */
    public static String[] split(String str)
    {
        return org.apache.commons.lang.StringUtils.split(str);
    }
    
    /**
     * 分割字符串
     * 
     * @param str
     *            目标字符串
     * @param separator
     *            分隔符
     * @return 分割后的集合数据
     */
    public static String[] split(String str, String separator)
    {
        return org.apache.commons.lang.StringUtils.split(str, separator);
    }
    
    /**
     * 获取子串
     * 
     * @param str
     *            目标字符串
     * @param start
     *            起始索引
     * 
     * @return 子串
     */
    public static String substring(String str, int start)
    {
        return org.apache.commons.lang.StringUtils.substring(str, start);
    }
    
    /**
     * 获取子串
     * 
     * @param str
     *            目标字符串
     * @param start
     *            起始索引
     * @param end
     *            结束索引
     * 
     * @return 子串
     */
    public static String substring(String str, int start, int end)
    {
        return org.apache.commons.lang.StringUtils.substring(str, start, end);
    }
    
    /**
     * 转换成字符串
     * 
     * @param obj
     *            obj
     * @return String
     */
    public static String toString(Object obj)
    {
        return obj == null ? null : obj.toString();
    }
    
    /**
     * 去空格字符串
     * 
     * @param str
     *            目标字符串
     * @return 去空格后的字符串
     */
    public static String trim(String str)
    {
        return org.apache.commons.lang.StringUtils.trim(str);
    }
    
    /**
     * 去空格字符串,如果字符串为empty则返回null
     * 
     * @param str
     *            目标字符串
     * @return 去空格后的字符串
     */
    public static String trimToNull(String str)
    {
        return org.apache.commons.lang.StringUtils.trimToNull(str);
    }
    
    /**
     * 去空格字符串,如果字符串为empty则返回""
     * 
     * @param str
     *            目标字符串
     * @return 去空格后的字符串
     */
    public static String trimToEmpty(String str)
    {
        return org.apache.commons.lang.StringUtils.trimToEmpty(str);
    }
    
    /**
     * 转换成大写字母
     * 
     * @param str
     *            目标字符串
     * @return 转换成大写字母
     */
    public static String upperCase(String str)
    {
        return org.apache.commons.lang.StringUtils.upperCase(str);
    }
    
    /**
     * 使用单引号包装字符串
     * 
     * 
     * @param str
     *            str
     * @param flag
     *            flag
     * @return String
     */
    public static String warp(String str, String flag)
    {
        if (isBlank(flag))
        {
            flag = DEFULT_WRAP_FLAG;
        }
        
        StringBuilder sb = new StringBuilder();
        sb.append(flag).append(str).append(flag);
        return sb.toString();
    }
    
    /**
     * 截取字符串
     * 
     * @param str
     *            待截取字符串
     * @param len
     *            字符长度
     * @return 截取后的字符串
     */
    public static String left(String str, int len)
    {
        return org.apache.commons.lang.StringUtils.left(str, len);
    }
    
    /**
     * 字符串XML解码
     * 
     * @param str
     *            待解码字符串
     * @return 解码后字符串
     */
    public static String unescapeXml(String str)
    {
        return StringEscapeUtils.unescapeXml(str);
    }
    
    /**
     * 反射对象成String类型
     * 
     * @param obj
     *            对象
     * @return 反射后的字符串
     */
    public static String reflectionToString(Object obj)
    {
        return ToStringBuilder.reflectionToString(obj);
    }
    
    
    /**
     * 分割字符串
     * 
     * @param str
     *            目标字符串
     * @param separator
     *            分隔符
     * @return 分割后的集合数据
     */
    public static List<Long> splitToLongList(String str, String separator)
    {
        List<Long> list = new ArrayList<Long>();
        
        if (isNotEmpty(str))
        {
            String[] strs = split(str, separator);
            for (String s : strs)
            {
                list.add(NumberUtils.toLong(s));
            }
        }
        
        return list;
    }
}