如何自定义字符串工具类

关注我，升职加薪就是你！
上午搞了篇自定义的数据计算工具类，其中用到了自定义的字符串工具类。由于当时只是分享了这个字符串工具类的一部分代码，今天下午就把它全部分享出来吧，小伙伴们也不用在网上到处找了。

package com.demo.nacosprovider.common;

import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @Author: Paul
 * @Date: 2021/09/26
 * @Function: 字符串工具类
 */
public class StringUtils {

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 判断 对象是否为空 支持 字符串 集合 数组 Map 类型的判断
     *@param: [object]
     *@return: boolean
     */
    public static boolean isEmptyObject(Object object) {
        if (object == null)
            return true;
        // 字符串
        if (object instanceof String) {
            return "".equals(object.toString());
        }
        // 集合
        else if (object instanceof Collection<?>) {
            return ((Collection<?>) object).isEmpty();
        }
        // 数组
        else if (object instanceof Object[]) {
            return ((Object[]) object).length == 0;
        }
        // Map
        else if (object instanceof Map<?, ?>) {
            return ((Map<?, ?>) object).isEmpty();
        }

        return false;
    }

    /**
     * @author: Paul
     * @time: 2021/09/26
     * @description: 判断字符串是否为空或者为空白串
     * @param: [str]
     * @return: boolean
     */
    public static boolean isEmptyStr(String str) {
        if (null == str || "".equals(str.trim())) {
            return true;
        } else
            return false;
    }

    /**
     * @author: Paul
     * @time: 2021/09/26
     * @description: 判断字符串是否非空
     * @param: [str]
     * @return: boolean
     */
    public static boolean isNotEmpty(String str) {
        return !isEmptyStr(str);
    }

    /**
     *@author: Paul
     *@time: 2021/09/26 
     *@description: 将null转化为空字符串
     *@param: [str]
     *@return: java.lang.String
     */
    public static String cancelNull(String str) {
        return str == null ? "" : str;
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 如果传入串为空或者undefined，那么用defaultStr初始化，否则返回截取空白后的字符串
     *@param: [str, defaultStr]
     *@return: java.lang.String
     */
    public static String getTrimStr(String str, String defaultStr) {
        if (isEmptyStr(str) || "undefined".equals(str)) {
            str = defaultStr;
        }
        return str.trim();
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 根据身份证号码获取生日的日期，可以处理15位或18位身份证号码
     *@param: [idCardNo]
     *@return: java.util.Date
     */
    public static Date getBirthdayFromIdCard(String idCardNo) {
        if (isEmptyStr(idCardNo)
                || !(idCardNo.matches(RegexStrings.REG_IDCARD_15) || idCardNo.matches(RegexStrings.REG_IDCARD_18))) {
            throw new IllegalArgumentException("idCardNo is not right");
        }
        String birdayStr = "";
        Date birday = null;
        DateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");

        try {
            if (!isEmptyStr(idCardNo) && 15 == idCardNo.length()) {
                birdayStr = "19" + idCardNo.substring(6, 12);
                birday = dateFormat.parse(birdayStr);
            } else if (!isEmptyStr(idCardNo) && 18 == idCardNo.length()) {
                birdayStr = idCardNo.substring(6, 14);
                birday = dateFormat.parse(birdayStr);
            }
        } catch (Exception e) {
            System.out.println("转换身份证号码的生日出错" + e.getMessage());
        }
        return birday;
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 根据身份证号码获取性别，可以处理15位或18位身份证号码
     *@param: [idCardNo]
     *@return: java.lang.String
     */
    public static String getGenderFromIdCard(String idCardNo) {
        String result = "";
        int genderNo = 0;
        if (isEmptyStr(idCardNo)
                || !(idCardNo.matches(RegexStrings.REG_IDCARD_15) || idCardNo.matches(RegexStrings.REG_IDCARD_18))) {
            throw new IllegalArgumentException("idCardNo is not right");
        }
        if (15 == idCardNo.length()) {
            genderNo = Integer.parseInt(idCardNo.substring(12));
        } else if (18 == idCardNo.length()) {
            genderNo = Integer.parseInt(idCardNo.substring(14, 17));
        }
        result = (genderNo % 2) > 0 ? "M" : "F";
        return result;
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 将15位身份证转换成为18位，如果已经是18位，那么直接返回
     *@param: [idCardNo]
     *@return: java.lang.String
     */
    public static String change15IdCardTo18(String idCardNo) {
        if (isEmptyStr(idCardNo)
                || !(idCardNo.matches(RegexStrings.REG_IDCARD_15) || idCardNo.matches(RegexStrings.REG_IDCARD_18))) {
            throw new IllegalArgumentException("idCardNo is not right");
        }
        if (15 == idCardNo.length()) {
            final int[] W = {7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2, 1};
            final String[] A = {"1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"};
            int i, j, s = 0;
            String newid;
            newid = idCardNo;
            newid = newid.substring(0, 6) + "19" + newid.substring(6, idCardNo.length());
            for (i = 0; i < newid.length(); i++) {
                j = Integer.parseInt(newid.substring(i, i + 1)) * W[i];
                s = s + j;
            }
            s = s % 11;
            newid = newid + A[s];
            return newid;
        } else
            return idCardNo;
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 从身份证中获取周岁
     *@param: [idCardNo]
     *@return: int
     */
    public static int getAgeFromIdCard(String idCardNo) {
        Date birthday = getBirthdayFromIdCard(idCardNo);
        Calendar calBirthday = Calendar.getInstance();
        calBirthday.setTime(birthday);
        calBirthday.get(Calendar.YEAR);

        Calendar calToday = Calendar.getInstance();
        int diffYear = calToday.get(Calendar.YEAR) - calBirthday.get(Calendar.YEAR);

        calBirthday.add(Calendar.YEAR, diffYear);
        if (calBirthday.after(calToday))// 如果今天的日期还没到达今年的生日，说明周岁还需要减1
        {
            diffYear = diffYear - 1;
        }
        return diffYear;
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 将字符串转成小写，可避免直接调用String.toLowerCase引起空指针的情况
     *@param: [str]
     *@return: java.lang.String
     */
    public static String toLowerCase(String str) {
        if (str == null)
            return "";
        else {
            return str.toLowerCase();
        }

    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 将字符串转成大写，可避免直接调用String.toUpperCase引起空指针的情况
     *@param: [str]
     *@return: java.lang.String
     */
    public static String toUpperCase(String str) {
        if (str == null)
            return "";
        else {
            return str.toUpperCase();
        }
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 将字符串的首字母转成大写
     *@param: [str]
     *@return: java.lang.String
     */
    public static String toUpper1stLetter(String str) {
        if (str == null)
            return "";
        else {
            return str.substring(0, 1).toUpperCase() + str.substring(1, str.length());
        }
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 用delimeter连接个字符串
     *@param: [list, delimeter]
     *@return: java.lang.String
     */
    public static String getMergeString(List<String> list, String delimeter) {
        if (list == null || list.isEmpty()) {
            return null;
        }
        if (list.size() == 1) {
            return (String) list.get(0);
        }
        StringBuffer sb = new StringBuffer();

        Iterator<String> iter = list.iterator();
        String str;
        while (iter.hasNext()) {
            str = iter.next();
            sb.append(str);
            sb.append(delimeter);
        }
        return sb.substring(0, sb.lastIndexOf(delimeter));
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 将String转为Integer
     *@param: [inValue]
     *@return: java.lang.Integer
     */
    public static Integer strToInt(String inValue) {
        int outValue = 0;
        try {
            outValue = Integer.parseInt(inValue);
        } catch (NumberFormatException ex) {
        } catch (NullPointerException ex) {
        }
        return Integer.valueOf(outValue);
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 判断字符串数组是否为空
     *@param: [arg]
     *@return: boolean
     */
    public static boolean isEmptyStrArray(String[] arg) {
        boolean flag = false;
        if (null == arg || arg.length == 0) {
            flag = true;
        }
        return flag;
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 将String转为BigDecimal 为空转换为零
     *@param: [str]
     *@return: java.math.BigDecimal
     */
    public static BigDecimal convertStrToBigDecimal(String str) {
        if (isEmptyStr(str)) {
            return new BigDecimal(0);
        }
        BigDecimal bigDecimal = new BigDecimal(0);
        try {
            bigDecimal = new BigDecimal(str);
        } catch (Exception e) {
        }
        return bigDecimal;
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 空字符串置换
     *@param: [in, out]
     *@return: java.lang.String
     */
    public static String emptyStrConvert(String in, String out) {
        return isNotEmpty(in) ? in : out;
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 字符串转长整型对象
     *@param: [inValue]
     *@return: java.lang.Long
     */
    public static Long strToLong(String inValue) {
        long outValue = 0;
        try {
            outValue = Long.parseLong(inValue);
        } catch (NumberFormatException ex) {
        } catch (NullPointerException ex) {
        }
        return Long.valueOf(outValue);
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 根据指定长度截取字符串,并追加结束符
     *@param: [s, n, endWith]
     *@return: java.lang.String
     */
    public static String subString(String s, int n, String endWith) {
        if (s == null) {
            return "";
        }
        Pattern p = Pattern.compile("^[\\u4e00-\\u9fa5]|[\\uff08]|[\\uff09]$");
        int i = 0, j = 0;
        char[] ch = s.toCharArray();
        char c;
        for (int k = 0; k < ch.length; k++) {
            c = ch[k];
            Matcher m = p.matcher(String.valueOf(c));
            i += m.find() ? 2 : 1;
            ++j;
            if (i == n)
                break;
            if (i > n) {
                --j;
                break;
            }
        }
        return s.substring(0, j) + endWith;
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 通过escape转码
     *@param: [src]
     *@return: java.lang.String
     */
    public static String escape(String src) {
        int i;
        char j;
        StringBuffer tmp = new StringBuffer();
        tmp.ensureCapacity(src.length() * 6);
        for (i = 0; i < src.length(); i++) {
            j = src.charAt(i);
            if (Character.isDigit(j) || Character.isLowerCase(j) || Character.isUpperCase(j))
                tmp.append(j);
            else if (j < 256) {
                tmp.append("%");
                if (j < 16)
                    tmp.append("0");
                tmp.append(Integer.toString(j, 16));
            } else {
                tmp.append("%u");
                tmp.append(Integer.toString(j, 16));
            }
        }
        return tmp.toString();
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 通过unescape转码
     *@param: [src]
     *@return: java.lang.String
     */
    public static String unescape(String src) {
        StringBuffer tmp = new StringBuffer();
        tmp.ensureCapacity(src.length());
        int lastPos = 0, pos = 0;
        char ch;
        while (lastPos < src.length()) {
            pos = src.indexOf("%", lastPos);
            if (pos == lastPos) {
                if (src.charAt(pos + 1) == 'u') {
                    ch = (char) Integer.parseInt(src.substring(pos + 2, pos + 6), 16);
                    tmp.append(ch);
                    lastPos = pos + 6;
                } else {
                    ch = (char) Integer.parseInt(src.substring(pos + 1, pos + 3), 16);
                    tmp.append(ch);
                    lastPos = pos + 3;
                }
            } else {
                if (pos == -1) {
                    tmp.append(src.substring(lastPos));
                    lastPos = src.length();
                } else {
                    tmp.append(src.substring(lastPos, pos));
                    lastPos = pos;
                }
            }
        }
        return tmp.toString();
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 字符串匹配()
     *@param: [regStr, matStr]
     *@return: boolean
     */
    public static boolean checkMatcher(String regStr, String matStr) {
        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(matStr);
        return matcher.matches();
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 判断两个字符串是否相等（空字符串与Null相等）
     *@param: [str1, str2]
     *@return: boolean
     */
    public static boolean isEqualStr(String str1, String str2) {
        return cancelNull(str1).equals(cancelNull(str2));
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 检查是否前后有空格
     *@param: [str]
     *@return: boolean
     */
    public static boolean isHaveBlankStr(String str) {
        String tmpStr = str.trim();
        return tmpStr.length() != str.length();
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 去除str中所有空格(前\中\后),如果入参为空或null，则返回原值
     *@param: [str]
     *@return: java.lang.String
     */
    public static String stringTrim(String str) {
        if (isNotEmpty(str)) {
            str = str.replaceAll("\\s+", "");
            str = stringFullCornerTrim(str);// 去掉全角空格
            return str;
        }
        return str;
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 去除str中所有空格(前\中\后),如果入参为空或null，则返回原值
     *@param: [str]
     *@return: java.lang.String
     */
    public static String getDefaultString(String str) {
        if (isEmptyStr(str)) {
            return "";
        }
        return str;
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 去掉全角空格(前\中\后),如果入参为空或null，则返回原值
     *@param: [str]
     *@return: java.lang.String
     */
    public static String stringFullCornerTrim(String str) {
        if (isNotEmpty(str)) {
            String regStartSpace = "^[　 ]*";// 左边空格
            String regEndSpace = "[　 ]*$";// 右边空格
            // 替换左右全角空格(中间不管)
            str = str.replaceAll(regStartSpace, "").replaceAll(regEndSpace, "");
            // str = str.replaceAll("\u3000", "");//去掉全角空格
        }
        return str;
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 将null对象转换成空字符串
     *@param: [obj]
     *@return: java.lang.String
     */
    public static String cancelNullObj(Object obj) {
        return obj == null ? "" : obj.toString();
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 判断是否有一个字符串为空
     *@param: [args]
     *@return: boolean
     */
    public static boolean isHaveOneEmpty(String... args) {
        if (null != args) {
            for (int i = 0; i < args.length; i++) {
                if (isEmptyStr(args[i])) {
                    return Boolean.TRUE;
                }
            }
        }
        return Boolean.FALSE;
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: 判断是否为纯数字类型的字符串
     *@param: [str]
     *@return: boolean
     */
    public static boolean isNumStr(String str) {
        boolean ret = false;
        ret = checkMatcher("^\\d+$", str);
        return ret;
    }

    /**
     *@author: Paul
     *@time: 2021/09/26
     *@description: map的key值从0开始往上增加
     *@param: [map, append]
     *@return: java.lang.String
     */
    public static String mapToString(Map<String, String> map, String append) {
        if (map == null || isEmptyStr(append)) {
            return "";
        }
        StringBuffer value = new StringBuffer();
        int index = 0;
        while (map.get(index + "") != null) {
            value.append(map.get(index + "")).append(append);
            index++;
        }
        if (isNotEmpty(value.toString())) {
            return value.substring(0, value.length() - append.length());
        }
        return value.toString();
    }

    /**
     * @author: Paul
     * @time: 2021/09/26
     * @description: 将字符串转为16进制
     * @param: [str]
     * @return: java.lang.String
     */
    public static String toHexString(String str) {
        byte[] b = str.getBytes();
        String s = "";
        for (int i = 0; i < b.length; i++) {
            s = s + Integer.toHexString(b[i]);
        }
        return s;
    }

    /**
     * @author: Paul
     * @time: 2021/09/26
     * @description: 将16进制字符串转换为原始的字符串
     * @param: [str]
     * @return: java.lang.String
     */
    public static String toStringHex(String str) throws UnsupportedEncodingException {
        byte[] b = new byte[str.length() / 2];
        for (int i = 0; i < b.length; i++) {
            b[i] = (byte) (0xff & Integer.parseInt(str.substring(i * 2, i * 2 + 2), 16));
        }
        return new String(b, "utf-8");
    }
}

好了，就写到这吧。
关注我，升职加薪就是你！