1、字符串混淆

2、创建随机字符串

3、创建重复字符的字符串

4、判断字符串是否为数字、小写字母、大写字母

5、比较版本号是否递增

public abstract class CannaStringUtils {
    private CannaStringUtils() {
    }

    private static final Random RANDOM = new Random();
    private static final char[] NUMBER = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
    private static final int NUMBER_LENGTH = NUMBER.length;
    private static final Integer MAX_STRING_LENGTH = 4096;

    public static final char DEFAULT_FILL_CHARACTER = '*';

    /**
     * 电话号码模糊混淆
     *
     * @param phone 电话号码
     * @param bit   混淆位数
     * @return
     */
    public static String obscurePhone(String phone, int bit) {
        return obscurePhone(phone, bit, DEFAULT_FILL_CHARACTER);
    }

    /**
     * 电话号码模糊混淆
     *
     * @param phone         电话号码
     * @param bit           混淆位数
     * @param fillCharacter 填充字符, 默认为 '*'
     * @return
     */
    public static String obscurePhone(String phone, int bit, char fillCharacter) {
        if (StringUtils.isBlank(phone)) {
            return null;
        }
        int length = phone.length();
        if (length <= bit) {
            return repeat(fillCharacter, length);
        }

        String replaceBit = repeat(fillCharacter, bit);
        int firstEnd = (length - bit) / 2;

        if ((length - bit) % 2 != 0) {
            firstEnd = firstEnd + 1;
        }

        int thirdStart = firstEnd + bit;
        if (thirdStart < length) {
            return phone.substring(0, firstEnd) + replaceBit + phone.substring(thirdStart);
        } else {
            return phone.substring(0, firstEnd) + replaceBit;
        }
    }

    /**
     * 重复字符的字符串
     * @param character
     * @param length
     * @return
     */
    public static String repeat(char character, int length) {
        char[] chars = new char[length];
        Arrays.fill(chars, character);
        return new String(chars);
    }

    /**
     * 返回一个定长的随机字符串(只包数字)
     * @param length 随机字符串长度
     * @return
     * @throws CannaException
     */
    public static String generateRandomNumber(int length) throws CannaException {
        if (length > MAX_STRING_LENGTH) {
            throw new CannaException(ToolsErrorType.OUT_OF_MAX_LENGTH);
        }
        char[] buf = new char[length];
        for (int i = 0; i < length; i++) {
            buf[i] = NUMBER[RANDOM.nextInt(NUMBER_LENGTH)];
        }

        return new String(buf);
    }

    /**
     * 校验版本字符串是否递增
     *
     * @param lastVersion 最新版本
     * @param currentVersion  当前版本
     * @throws CannaException currentVersion < lastVersion
     */
    public static void versionCheckInc(String lastVersion, String currentVersion) throws CannaException {
        if (StringUtils.isBlank(currentVersion)) {
            throw new CannaException(ToolsErrorType.CURRENT_NULL);
        }

        if (currentVersion.equals(lastVersion)) {
            throw new CannaException(ToolsErrorType.EXIST);
        }

        String[] lasts = lastVersion.split("\\.");
        String[] currs = currentVersion.split("\\.");

        if (lasts.length != currs.length) {
            throw new CannaException(ToolsErrorType.LENGTH_NOT_MATCH);
        }

        boolean versionRight = true;
        for (int i = 0; i < lasts.length; i++) {
            if (Integer.parseInt(currs[i]) < Integer.parseInt(lasts[i])) {
                versionRight = false;
                break;
            } else if (Integer.parseInt(currs[i]) > Integer.parseInt(lasts[i])) {
                break;
            }
        }

        if (!versionRight) {
            throw new CannaException(ToolsErrorType.NOT_INCREASE);
        }
    }

    /**
     * 是否是大写字母或数字
     * @param cs
     * @return
     */
    public static boolean isNumericUpperCase(CharSequence cs) {
        if (StringUtils.isBlank(cs)) {
            return false;
        }
        int size = cs.length();

        for (int i = 0; i < size; ++i) {
            if (!Character.isUpperCase(cs.charAt(i)) && !Character.isDigit(cs.charAt(i))) {
                return false;
            }
        }

        return true;
    }

    /**
     * 是否是小写字母或数字
     * @param cs
     * @return
     */
    public static boolean isNumericLowerCase(CharSequence cs) {
        if (StringUtils.isBlank(cs)) {
            return false;
        }
        int size = cs.length();

        for (int i = 0; i < size; ++i) {
            if (!Character.isLowerCase(cs.charAt(i)) && !Character.isDigit(cs.charAt(i))) {
                return false;
            }
        }

        return true;
    }

    /**
     * 是否是字母
     * @param cs
     * @return
     */
    public static boolean isAlpha(CharSequence cs) {
        if (StringUtils.isBlank(cs)) {
            return false;
        }
        int size = cs.length();

        for (int i = 0; i < size; ++i) {
            if (!Character.isUpperCase(cs.charAt(i)) && !Character.isLowerCase(cs.charAt(i))) {
                return false;
            }
        }

        return true;
    }

    /**
     * 是否是数字或字母
     * @param cs
     * @return
     */
    public static boolean isNumericAlpha(CharSequence cs) {
        if (StringUtils.isBlank(cs)) {
            return false;
        }
        int size = cs.length();

        for (int i = 0; i < size; ++i) {
            if (!Character.isUpperCase(cs.charAt(i)) && !Character.isLowerCase(cs.charAt(i)) && !Character.isDigit(cs.charAt(i))) {
                return false;
            }
        }

        return true;
    }
}