字符串处理工具类

字符串处理工具类

import java.util.Arrays;
 
public class StringUtils {
 
    /**
     * 将字符串反转
     * @param str 要反转的字符串
     * @return 反转后的字符串
     */
    public static String reverseString(String str) {
        return new StringBuilder(str).reverse().toString();
    }
 
    /**
     * 判断字符串是否为空
     * @param str 要判断的字符串
     * @return 如果字符串为空则返回true，否则返回false
     */
    public static boolean isEmpty(String str) {
        return str == null || str.isEmpty();
    }
 
    /**
     * 去除字符串两端的空格
     * @param str 要处理的字符串
     * @return 去除两端空格后的字符串
     */
    public static String trim(String str) {
        return str.trim();
    }
 
    /**
     * 将字符串转换为大写
     * @param str 要转换的字符串
     * @return 转换为大写后的字符串
     */
    public static String toUpperCase(String str) {
        return str.toUpperCase();
    }
 
    /**
     * 将字符串转换为小写
     * @param str 要转换的字符串
     * @return 转换为小写后的字符串
     */
    public static String toLowerCase(String str) {
        return str.toLowerCase();
    }
 
    /**
     * 判断字符串是否以指定的前缀开始
     * @param str 要判断的字符串
     * @param prefix 前缀
     * @return 如果字符串以指定的前缀开始则返回true，否则返回false
     */
    public static boolean startsWith(String str, String prefix) {
        return str.startsWith(prefix);
    }
 
    /**
     * 判断字符串是否以指定的后缀结束
     * @param str 要判断的字符串
     * @param suffix 后缀
     * @return 如果字符串以指定的后缀结束则返回true，否则返回false
     */
    public static boolean endsWith(String str, String suffix) {
        return str.endsWith(suffix);
    }
 
    /**
     * 判断字符串是否包含指定子字符串
     * @param str 要判断的字符串
     * @param subStr 子字符串
     * @return 如果字符串包含指定子字符串则返回true，否则返回false
     */
    public static boolean contains(String str, String subStr) {
        return str.contains(subStr);
    }
 
    /**
     * 将字符串按照指定分隔符拆分为数组
     * @param str 要拆分的字符串
     * @param delimiter 分隔符
     * @return 拆分后的字符串数组
     */
    public static String[] split(String str, String delimiter) {
        return str.split(delimiter);
    }
 
    /**
     * 将字符串按照指定分隔符拆分为列表
     * @param str 要拆分的字符串
     * @param delimiter 分隔符
     * @return 拆分后的字符串列表
     */
    public static List<String> splitToList(String str, String delimiter) {
        return Arrays.asList(str.split(delimiter));
    }
 
    /**
     * 替换字符串中的指定子字符串
     * @param str 要替换的字符串
     * @param target 要被替换的子字符串
     * @param replacement 替换字符串
     * @return 替换后的字符串
     */
    public static String replace(String str, String target, String replacement) {
        return str.replace(target, replacement);
    }
 
    /**
     * 将字符串转换为首字母大写
     * @param str 要转换的字符串
     * @return 首字母大写的字符串
     */
    public static String capitalize(String str) {
        if (isEmpty(str)) {
            return str;
        }
        return Character.toUpperCase(str.charAt(0)) + str.substring(1);
    }
 
    /**
     * 将字符串转换为首字母小写
     * @param str 要转换的字符串
     * @return 首字母小写的字符串
     */
    public static String uncapitalize(String str) {
        if (isEmpty(str)) {
            return str;
        }
        return Character.toLowerCase(str.charAt(0)) + str.substring(1);
    }
 
    /**
     * 将字符串转换为驼峰命名法（首字母小写）
     * 例如: "hello_world" -> "helloWorld"
     * @param str 要转换的字符串
     * @return 转换后的字符串
     */
    public static String toCamelCase(String str) {
        if (isEmpty(str)) {
            return str;
        }
        StringBuilder sb = new StringBuilder();
        String[] words = str.split("_");
        sb.append(words[0]);
        for (int i = 1; i < words.length; i++) {
            sb.append(capitalize(words[i]));
        }
        return sb.toString();
    }
 
    /**
     * 将字符串转换为帕斯卡命名法（首字母大写）
     * 例如: "hello_world" -> "HelloWorld"
     * @param str 要转换的字符串
     * @return 转换后的字符串
     */
    public static String toPascalCase(String str) {
        return capitalize(toCamelCase(str));
    }
 
    /**
     * 将字符串转换为下划线命名法（小写字母，单词间用下划线分隔）
     * 例如: "HelloWorld" -> "hello_world"
     * @param str 要转换的字符串
     * @return 转换后的字符串
     */
    public static String toSnakeCase(String str) {
        if (isEmpty(str)) {
            return str;
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (Character.isUpperCase(c)) {
                if (i > 0) {
                    sb.append('_');
                }
                sb.append(Character.toLowerCase(c));
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }
 
    /**
     * 获取重复指定次数的字符串
     * @param str 要重复的字符串
     * @param repeatCount 重复次数
     * @return 重复指定次数后的字符串
     */
    public static String repeat(String str, int repeatCount) {
        if (repeatCount <= 0) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < repeatCount; i++) {
            sb.append(str);
        }
        return sb.toString();
    }
 
    /**
     * 获取字符串的长度（考虑Unicode扩展字符）
     * @param str 要获取长度的字符串
     * @return 字符串的长度
     */
    public static int length(String str) {
        if (isEmpty(str)) {
            return 0;
        }
        return str.codePointCount(0, str.length());
    }
 
    /**
     * 判断两个字符串是否相等（忽略大小写）
     * @param str1 字符串1
     * @param str2 字符串2
     * @return 如果两个字符串相等则返回true，否则返回false
     */
    public static boolean equalsIgnoreCase(String str1, String str2) {
        return str1.equalsIgnoreCase(str2);
    }
 
    /**
     * 判断字符串是否为数字
     * @param str 要判断的字符串
     * @return 如果字符串为数字则返回true，否则返回false
     */
    public static boolean isNumeric(String str) {
        if (isEmpty(str)) {
            return false;
        }
        for (char c : str.toCharArray()) {
            if (!Character.isDigit(c)) {
                return false;
            }
        }
        return true;
    }
}