String 字符串工具类

package com.example.utils.utils;

import java.text.DecimalFormat;

import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;
/**
 * @ClassName StringUtil
 * @Description TODO
 * @Author wushaopei
 * @Date 2019/7/22 11:28
 * @Version 1.0
 */
public class StringUtil {

    /**逗号*/
    public static final String UNDERLINE_DH = ",";
    /**中文逗号*/
    public static final String UNDERLINE_ZWDH = ",";
    /**竖线*/
    public static final String UNDERLINE_SX = "|";
    /**下划线*/
    public static final String UNDERLINE_XHX = "_";
    /**空格*/
    public static final String UNDERLINE_KG = " ";
    /**冒号*/
    public static final String UNDERLINE_MH = ":";
    /**英文 点*/
    public static final String UNDERLINE_D = ".";
    /**英文 横杠*/
    public static final String UNDERLINE_HG = "-";
    /**英文  x*/
    public static final String UNDERLINE_X = "x";
    /**英文  斜杠/*/
    public static final String UNDERLINE_XG = "/";
    /**英文 单字符     逗号,/*/
    public static final char UNDERLINE_CHAR_DH = ',';


    /**英文转义 点*/
    public static final String UNDERLINE_ESCAPE_D = "\\.";
    /**转义竖线*/
    public static final String UNDERLINE_ESCAPE_SX = "\\|";
    public static final String ESCAPE_SX = "\\|";
    public static final String SX = "|";
    public static final String HG = "-";
    public static final String KC = "";
    public static final String MH = ":";
    public static final String KG = " ";
    public static final String DH = ",";


    /**红波*/
    public static final String HONGBO_ZW_STRING = "红波";
    /**蓝波*/
    public static final String LANBO_ZW_STRING = "蓝波";
    /**绿波*/
    public static final String LVBO_ZW_STRING = "绿波";

    /** 鼠 */
    public static final String SHU_ZW_STRING = "鼠";
    /** 牛 */
    public static final String NIU_ZW_STRING = "牛";
    /** 虎 */
    public static final String HU_ZW_STRING = "虎";
    /** 兔 */
    public static final String TU_ZW_STRING = "兔";
    /** 龙 */
    public static final String LONG_ZW_STRING = "龙";
    /** 蛇 */
    public static final String SHE_ZW_STRING = "蛇";
    /** 马 */
    public static final String MA_ZW_STRING = "马";
    /** 羊 */
    public static final String YANG_ZW_STRING = "羊";
    /** 猴 */
    public static final String HOU_ZW_STRING = "猴";
    /** 鸡 */
    public static final String JI_ZW_STRING = "鸡";
    /** 狗 */
    public static final String GOU_ZW_STRING = "狗";
    /** 猪 */
    public static final String ZHU_ZW_STRING = "猪";


    /** 自主开奖的map对应的key值*/
    //最低中奖金额
    public static final String MIN_WIN_AMOUNT = "minWinMoney";

    /** 金流方向数据字典对应的key值*/
    /**为盈利的类型 */
    public static final String ACCOUNT_DETAILS_POROFIT_DICT_KEY = "41,12,13,92,93,81,14,83,112,113";
    /**为亏损的类型 */
    public static final String ACCOUNT_DETAILS_LOSS_DICT_KEY = "71,72,73,74,75,21,31,51,91,82,15,16,17,61,94,111,76";


    /**
     * 首字母小写
     *
     * @return String
     * @throws
     */
    public static String firstToLowerCase(String str) {
        if (str != null && str.length() != 0) {
            return Character.toLowerCase(str.charAt(0)) + str.substring(1);
        }
        return str;
    }

    /**
     * 首字母大些
     *
     * @return String
     * @throws
     */
    public static String firstToUpperCase(String str) {
        if (str != null && str.length() != 0) {
            return Character.toUpperCase(str.charAt(0)) + str.substring(1);
        }
        return str;
    }

    /**
     * 将页面或PO字段转换成全大写并以下划线分隔的数据库字段
     *
     * @param param 例如： custName
     * @return 换换后字符串 CUST_NAME
     */
    public static String capitalConvertUnderline(String dtoName) {
        StringBuffer sub = null;
        if (isNotBlank(dtoName)) {
            char[] ch = dtoName.toCharArray();
            sub = new StringBuffer();
            String temp = null; //
            for (int i = 0; i < dtoName.length(); i++) {
                temp = String.valueOf(ch[i]);
                if (StringUtil.isNotBlank(temp)
                        && Character.isUpperCase(ch[i])) {
                    sub.append(UNDERLINE_XHX + ch[i]);
                } else {
                    sub.append(ch[i]);
                }
            }
            return sub.toString().toUpperCase();
        }
        return null;
    }

    /**
     * 将页面或PO字段转换成以下划线分隔的数据库字段
     *
     * @param param 例如： custName
     * @return 换换后字符串 CUST_NAME
     */
    public static String camelToUnderline(String param) {
        if (param == null || "".equals(param.trim())) {
            return "";
        }
        int len = param.length();
        StringBuilder sb = new StringBuilder(len);
        for (int i = 0; i < len; i++) {
            char c = param.charAt(i);
            if (Character.isUpperCase(c)) {
                sb.append(UNDERLINE_XHX);
                sb.append(Character.toLowerCase(c));
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }

    /**
     * 判断字符串是否是null或者""
     *
     * @param str
     * @return
     */
    public static boolean isBlank(String str) {
        if (str == null) {
            return true;
        } else if (str.length() == 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 判断字符串是否不为空
     *
     * @param str
     * @return
     */
    public static boolean isNotBlank(String str) {
        return !isBlank(str);
    }

    /**
     * 用分隔符expr 分割str字符串，返回string[]数组
     *
     * @param str
     *            ：要分割的字符串
     * @param expr
     *            ：分隔符
     * @return String[]
     */
    public static String[] stringToArray(String str, String expr) {
        return str.split(expr);
    }

    /**
     * 将字符串数组以分隔符方式返回字符串
     *
     * @param arr
     * @param expr
     * @return
     */
    public static String arrayToString(String[] arr, String expr) {
        String strInfo = "";
        if (arr != null && arr.length > 0) {
            StringBuffer sf = new StringBuffer();
            for (String str : arr) {
                sf.append(str);
                sf.append(expr);
            }
            strInfo = sf.substring(0, sf.length() - 1);
        }
        return strInfo;
    }

    /**
     * 将list集合里字符串用expr分隔符连接，返回字符串
     *
     * @param arr
     * @param expr
     * @return
     */
    public static String listToString(List<String> list, String expr) {
        String strInfo = "";
        if (list != null && list.size() > 0) {
            StringBuffer sf = new StringBuffer();
            for (String str : list) {
                sf.append(str);
                sf.append(expr);
            }
            strInfo = sf.substring(0, sf.length() - 1);
        }
        return strInfo;
    }

    /**
     * 屏蔽相关信息
     *
     * @param arr
     * @param expr
     * @return
     */
    public static String shieldAll(String str) {
        str = shieldEmail(str);
        str = shieldMobile(str);
        str = shieldTelephone(str);
        str = shieldQQ(str);
        return str;
    }

    /**
     * 屏蔽EMAIL
     *
     * @param email
     * @return
     */
    public static String shieldEmail(String email) {
        if (!email.isEmpty()) {
            String emailRegEx = "([a-zA-Z0-9_\\-\\.]+)@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.)|(([a-zA-Z0-9\\-]+\\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\\]?)";
            Pattern emailPattern = Pattern.compile(emailRegEx);
            Matcher emailMatcher = emailPattern.matcher(email);
            while (emailMatcher.find()) {
                String oldSubStr = emailMatcher.group(); // 获得邮箱地址
                int location = oldSubStr.indexOf("@");
                String temp = oldSubStr.substring(0, location); // 获得邮箱账号
                String newSubStr = oldSubStr.replace(temp, "****"); // 用星号替代邮箱账号
                email = email.replace(oldSubStr, newSubStr); // 替换补充说明中的邮箱地址
            }
        }
        return email;
    }

    /**
     * 屏蔽手机号码
     *
     * @param mobile
     * @return
     */
    public static String shieldMobile(String mobile) {
        if (!mobile.isEmpty()) {
            String mobileRegEx = "((13[0-9])|(15[0-9])|(18[0-9])|(17[0-9]))\\d{8}";
            Pattern mobilePattern = Pattern.compile(mobileRegEx);
            Matcher mobileMatcher = mobilePattern.matcher(mobile);
            while (mobileMatcher.find()) {
                String oldSubStr = mobileMatcher.group(); // 获得手机号码
                String temp = oldSubStr.substring(3, oldSubStr.length()); // 截取手机号码后八位
                String newSubStr = oldSubStr.replace(temp, "********"); // 用星号替代手机号码后八位
                mobile = mobile.replace(oldSubStr, newSubStr); // 替换补充说明中的手机号码
            }
        }
        return mobile;
    }

    /**
     * 屏蔽座机号码
     *
     * @param telephone
     * @return
     */
    public static String shieldTelephone(String telephone) {
        if (!telephone.isEmpty()) {
            String telephoneRegEx = "(0[0-9]{2,3})?[-| ]([2-9][0-9]{6,7})+(-[0-9]{1,4})?";
            Pattern telephonePattern = Pattern.compile(telephoneRegEx);
            Matcher telephoneMatcher = telephonePattern.matcher(telephone);
            while (telephoneMatcher.find()) {
                String oldSubStr = telephoneMatcher.group(); // 获得座机号码
                String temp = oldSubStr.substring(5, oldSubStr.length()); // 截取座机号码后7位
                String newSubStr = oldSubStr.replace(temp, "*******"); // 用星号替代座机号码后7位
                telephone = telephone.replace(oldSubStr, newSubStr); // 替换补充说明中的座机号码
            }
        }
        return telephone;
    }

    /**
     * 屏蔽QQ
     *
     * @param telephone
     * @return
     */
    public static String shieldQQ(String qq) {
        if (!qq.isEmpty()) {
            String qqRegEx = "[1-9][0-9]{5,9}";
            Pattern qqPattern = Pattern.compile(qqRegEx);
            Matcher qqMatcher = qqPattern.matcher(qq);
            while (qqMatcher.find()) {
                String oldSubStr = qqMatcher.group(); // 获得QQ号码
                String temp = oldSubStr.substring(2, oldSubStr.length()); // 截取QQ号码
                String newSubStr = oldSubStr.replace(temp, "******"); // 用星号替代
                qq = qq.replace(oldSubStr, newSubStr); // 替换补充说明中的QQ号码
            }
        }
        return qq;
    }

    public static String toGb2312(String str) {
        if (str == null) {
            return null;
        }
        String retStr = str;
        byte[] b;
        try {
            b = str.getBytes("ISO8859_1");
            for (int i = 0; i < b.length; i++) {
                byte b1 = b[i];
                if (b1 == 63) {
                    break; // 1
                } else if (b1 > 0) {
                    continue;// 2
                } else if (b1 < 0) { // 不可能为0，0为字符串结束符
                    // 小于0乱码
                    retStr = new String(b, "GB2312");
                    break;
                }
            }
        } catch (UnsupportedEncodingException e) {
            // e.printStackTrace();
        }
        return retStr;
    }

    /**
     * 判断字符是否是中文
     *
     * @param c
     *            字符
     * @return 是否是中文
     */
    public static boolean isChinese(char c) {
        Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
        if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
                || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
                || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
                || ub == Character.UnicodeBlock.GENERAL_PUNCTUATION
                || ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
                || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS) {
            return true;
        }
        return false;
    }

    /**
     * 判断字符串是否是乱码
     *
     * @param strName
     *            字符串
     * @return 是否是乱码
     */
    public static boolean isMessyCode(String strName) {
        Pattern p = Pattern.compile("\\s*|\t*|\r*|\n*");
        Matcher m = p.matcher(strName);
        String after = m.replaceAll("");
        String temp = after.replaceAll("\\p{P}", "");
        char[] ch = temp.trim().toCharArray();
        float chLength = ch.length;
        float count = 0;
        for (int i = 0; i < ch.length; i++) {
            char c = ch[i];
            if (!Character.isLetterOrDigit(c)) {
                if (!isChinese(c)) {
                    count = count + 1;
                }
            }
        }
        float result = count / chLength;
        if (result > 0.4) {
            return true;
        } else {
            return false;
        }

    }

    public static boolean validateMobile(String mobile) {
        if(StringUtils.isEmpty(mobile)) {
            return false;
        }
        String REGEX_MOBILE = "^((17[0-9])|(14[0-9])|(13[0-9])|(15[^4,\\D])|(18[0,5-9]))\\d{8}$";
        Pattern pMobile = Pattern.compile(REGEX_MOBILE);
        return pMobile.matcher(mobile).matches();
    }

    public static boolean validateEmail(String email) {
        if(StringUtils.isEmpty(email)) {
            return false;
        }
        String REGEX_EMAIL = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
        Pattern pEmail = Pattern.compile(REGEX_EMAIL);
        return pEmail.matcher(email).matches();
    }

    /**
     * 判断是否为数字
     *
     * @param object
     * @return
     */
    public static boolean isNumber(Object object) {
        if (object == null) {
            return false;
        }
        String value = object.toString();
        return value.matches("\\d+");
    }

    /**
     * 计算采用编码方式时字符串所占字节数
     *
     * @param content
     * @return
     */
    public static int getByteSize(String encode, String content) {
        int size = 0;
        if (null != content) {
            try {
                // 汉字采用utf-8编码时占3个字节
                size = content.getBytes(encode).length;
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        return size;
    }

    public static String objToString(Object obj) {
        if (obj != null) {
            return obj.toString();
        } else {
            return "";
        }
    }

    /**
     * 版本号只加一个版本，逢9进1
     *
     * @author administrator
     * @time 2017年5月23日
     *
     * @param arg
     * @return
     */
    public static String versionIncre(String arg) {
        String[] argAry = arg.split(UNDERLINE_ESCAPE_D);
        for (int i = argAry.length-1; i > -1; i--) {
            int num = Integer.valueOf(argAry[i]);
            if (num == 9) {
                argAry[i] = i == 0 ? (num + 1) + "" : "0";
            }else {
                argAry[i] = (num + 1) + "";
                break;
            }
        }
        return StringUtils.join(argAry, UNDERLINE_D);
    }

    /**
     * 将double转成非科学计数法的字符串
     * @param Double
     * @return
     */
    public static String formatFloatNumber(Double value) {
        if(value != null){
            if(value.doubleValue() != 0.00){
                java.text.DecimalFormat df = new java.text.DecimalFormat("########.00");
                return df.format(value.doubleValue());
            }else{
                return "0.00";
            }
        }
        return "";
    }

    public static boolean validateQQ(String qq) {
        if(StringUtils.isEmpty(qq)) {
            return false;
        }
        String REGEX_QQ = "[1-9][0-9]{4,14}";
        Pattern pQQ = Pattern.compile(REGEX_QQ);
        return pQQ.matcher(qq).matches();
    }

    public static String setAgentCodeToOrderNo(String orderNo, String agentCode) {
        return orderNo+"zzz"+agentCode;
    }

    public static String setAgentNumToOrderNo(Integer num, String orderNo) {
        return num+orderNo;
    }

    public static String getOrderNoByOrder(String orderNo) {
        String ss = orderNo.substring(3, orderNo.length());
        return ss;
    }

    public static String getNumByOrder(String orderNo) {
        String ss = orderNo.substring(0, 3);
        return ss;
    }

    public static String getAgentCodeByOrderNo(String orderNoZZZagentCode) {
        String[] ss = orderNoZZZagentCode.split("zzz");
        return ss[1];
    }

    public static String getOrderNoByOrderNo(String orderNoZZZagentCode) {
        String[] ss = orderNoZZZagentCode.split("zzz");
        return ss[0];
    }

    /**
     *
     * 将String转换成unicode编码格式
     * @param str
     * @return String
     * @throws
     */
    public static String unicodeEncoding(String str) {
        if (str == null||str.trim().length()==0) {
            return str;
        }
        StringBuffer unicodeBytes = new StringBuffer();
        for (int byteIndex = 0; byteIndex < str.length(); byteIndex++) {
            String hexB = Integer.toHexString(str.charAt(byteIndex));
            unicodeBytes.append("\\u");
            if (hexB.length() <= 2) {
                unicodeBytes.append("00");
            }
            unicodeBytes.append(hexB);
        }
        return unicodeBytes.toString();
    }


    /**
     * 将unicode转中文
     * @param dataStr
     * @return
     */
    public static String decodeUnicode(String dataStr) {
        int start = 0;
        int end = 0;
        StringBuffer buffer = new StringBuffer();
        while (start > -1) {
            end = dataStr.indexOf("\\u", start + 2);
            String charStr = "";
            if (end == -1) {
                charStr = dataStr.substring(start + 2, dataStr.length());
            } else {
                charStr = dataStr.substring(start + 2, end);
            }
            char letter = (char) Integer.parseInt(charStr, 16); // 16进制parse整形字符串。
            buffer.append(new Character(letter).toString());
            start = end;
        }
        return buffer.toString();
    }

    /**
     * 数字类型强转,如果是小数类型保留两位小数
     * @param v
     * @return
     */
    @SuppressWarnings("unchecked")
    public static String castNumber(Object v){
        DecimalFormat df  = new DecimalFormat("######0.00");
        String s = df.format(v);
        return s;
    }



   //main 方法测试 编码、解码 结果

    public static void main(String[] args) {

        System.out.println(unicodeEncoding("康娜酱"));

        String s = unicodeEncoding("康娜酱");
        String s1 = decodeUnicode(s);
        System.out.println(s1);
    }

}

main方法测试结果：

\u5eb7\u5a1c\u9171
康娜酱