【工具类】自动识别字符串命名风格并转换成指定命名风格

支持的转换和识别的格式：

• 小写命名（lowercase）、大写命名（UPPERCASE）
• 驼峰命名（camelCase）、帕斯卡命名（PascalCase）
• 下划线命名（snake_case）、大写下划线命名（SCREAMING_SNAKE_CASE）、首字母大写下划线命名（Capital_Snake_Case）
• 串联命名（kebab-case）、大写串联命名（SCREAMING-KEBAB-CASE）、首字母大写串联命名（Capital-Kebab-Case）

 POM文件中导入依赖

<!-- hutool工具类 -->
<dependency>
	<groupId>cn.hutool</groupId>
	<artifactId>hutool-all</artifactId>
	<version>5.8.21</version>
</dependency>

<!-- lombok -->
<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
	<version>1.18.28</version>
	<scope>provided</scope>
</dependency>

创建命名风格枚举类

import lombok.Getter;

/**
 * 命名风格
 *
 * @author hanYong
 */
@Getter
public enum NamingStyle {

    /**
     * 小写命名法是指所有字母都是小写的命名方式。例如：myclass、calculatearea
     */
    LOWER_CASE("小写命名", "^[a-z]+([a-z]+)*$", null),

    /**
     * 大写命名法是指所有字母都是大写的命名方式。例如：MYCLASS、CALCULATEAREA
     */
    UPPER_CASE("大写命名", "^[A-Z]+([A-Z]+)*$", null),

    /**
     * 除了第一个单词的首字母小写外，后续的每个单词的首字母都大写。例如：myVariableName、calculateArea
     */
    CAMEL_CASE("驼峰命名", "^[a-z]+([A-Z][a-z]+)*$", null),

    /**
     * ?每个单词的首字母都大写。也被称为大驼峰命名法。例如：MyClass、CalculateArea
     */
    PASCAL_CASE("帕斯卡命名", "^([A-Z][a-z]+)*$", null),

    /**
     * 所有字母小写，单词之间使用下划线分隔。例如：my_variable_name、calculate_area。
     */
    SNAKE_CASE("下划线命名", "^[a-z]+(_[a-z]+)*$", null),

    /**
     * 所有字母大写，单词之间使用下划线分隔。例如：MY_VARIABLE_NAME、CALCULATE_AREA。
     */
    SCREAMING_SNAKE_CASE("大写下划线命名", "^[A-Z]+(_[A-Z]+)*$", null),

    /**
     * ?每个单词的首字母都大写，单词之间使用下划线分隔。例如：My_Variable_Name、Calculate_Area。
     */
    CAPITAL_SNAKE_CASE("首字母大写下划线命名", "^([A-Z][a-z]+)+(_[A-Z][a-z]+)*$", null),

    /**
     * 所有字母小写，单词之间使用连字符分隔。例如：my-file-name、calculate-area
     */
    KEBAB_CASE("串联命名", "^[a-z]+(-[a-z]+)*$", null),

    /**
     * 所有字母大写，单词之间使用连字符分隔。例如：MY-FILE-NAME、CALCULATE-AREA
     */
    SCREAMING_KEBAB_CASE("大写串联命名", "^[A-Z]+(-[A-Z]+)*$", null),

    /**
     * 每个单词的首字母都大写，单词之间使用连字符分隔。例如：My-File-Name、Calculate-Area
     */
    CAPITAL_KEBAB_CASE("首字母大写串联命名", "^([A-Z][a-z]+)+(-[A-Z][a-z]+)*$", null);

    //language=RegExp
    /**
     * 命名
     */
    private String name;

    /**
     * 正则标识
     */
    private String regex;

    /**
     * 方法名
     */
    private String method;


    NamingStyle(String name, String regex, String method) {
        this.name = name;
        this.regex = regex;
        this.method = method;
    }

    public static NamingStyle getNamingStyle(String name) {
        for (NamingStyle namingStyle : NamingStyle.values()) {
            if (name.matches(namingStyle.getRegex())) {
                return namingStyle;
            }
        }
        return null;
    }

    public boolean matches(String name){
        return name.matches(this.regex);
    }
}

创建命名风格转换工具类

import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.text.CharSequenceUtil;
import cn.hutool.core.text.StrPool;
import cn.hutool.core.util.ObjectUtil;
import com.smartadmin.common.enums.NamingStyle;

import java.util.List;
import java.util.stream.Collectors;

/**
 * CaseFormatUtil
 *
 * 命名格式转换工具类
 * @author: hanYong
 * @createTime: 2023-08-29
 */
public class CaseFormatUtil {

    /**
     * 转换字符串
     *
     * @param oldStr 原始字符串
     * @param namingStyle 命名风格
     * @return 转换后的字符串
     */
    public static String to(String oldStr, NamingStyle namingStyle){
        if(CharSequenceUtil.isBlank(oldStr)){
            return null;
        }

        // 解析字符串
        List<String> list = parse(oldStr);

        namingStyle = ObjectUtil.defaultIfNull(namingStyle, NamingStyle.CAMEL_CASE);

        // 格式化字符串
        return format(list, namingStyle);
    }

    /**
     * 解析字符串
     *
     * @param oldStr 原始字符串
     * @return 解析后的字符串
     */
    private static List<String> parse(String oldStr){

        if(oldStr.contains(StrPool.UNDERLINE)){
            // 下划线
            return CharSequenceUtil.splitTrim(oldStr, StrPool.UNDERLINE).stream()
                    .map(String::toLowerCase).toList();
        }

        if(oldStr.contains(StrPool.DASHED)){
            // 串联
            return CharSequenceUtil.splitTrim(oldStr, StrPool.DASHED).stream()
                    .map(String::toLowerCase).toList();
        }

        if(NamingStyle.LOWER_CASE.matches(oldStr) || NamingStyle.UPPER_CASE.matches(oldStr)){
            // 大小写
            return ListUtil.of(oldStr.toLowerCase());
        }

        if(NamingStyle.CAMEL_CASE.matches(oldStr) || NamingStyle.PASCAL_CASE.matches(oldStr)){
            // 驼峰
            return ListUtil.of(oldStr.split("(?=[A-Z])"));
        }

        return ListUtil.empty();
    }

    /**
     * 格式化字符串
     *
     * @param strList 字符串集合
     * @param namingStyle 命名风格
     * @return 格式化后的字符串
     */
    private static String format(List<String> strList, NamingStyle namingStyle){
        if(ObjectUtil.isEmpty(strList)){
            return null;
        }

        if(ObjectUtil.equal(namingStyle, NamingStyle.LOWER_CASE)){
            // 小写命名
            return String.join("", strList);
        } else if (ObjectUtil.equal(namingStyle, NamingStyle.UPPER_CASE)){
            // 大写命名
            return String.join("", strList).toUpperCase();
        }

        if(ObjectUtil.equal(namingStyle, NamingStyle.CAMEL_CASE)){
            // 驼峰命名
            String collect = strList.stream().map(CharSequenceUtil::upperFirst)
                    .collect(Collectors.joining());
            return CharSequenceUtil.lowerFirst(collect);
        } else if (ObjectUtil.equal(namingStyle, NamingStyle.PASCAL_CASE)){
            // 帕斯卡命名
            return strList.stream().map(CharSequenceUtil::upperFirst)
                    .collect(Collectors.joining());
        }

        // ############################## 下滑命名法 ##############################
        if (ObjectUtil.equal(namingStyle, NamingStyle.SNAKE_CASE)){
            // 下划线命名
            return String.join(StrPool.UNDERLINE, strList).toLowerCase();
        } else if (ObjectUtil.equal(namingStyle, NamingStyle.SCREAMING_SNAKE_CASE)){
            // 大写下划线命名
            return String.join(StrPool.UNDERLINE, strList).toUpperCase();
        } else if (ObjectUtil.equal(namingStyle, NamingStyle.CAPITAL_SNAKE_CASE)){
            // 首字母大写下划线命名
            return strList.stream().map(CharSequenceUtil::upperFirst)
                    .collect(Collectors.joining(StrPool.UNDERLINE));
        }

        // ############################## 串联命名法 ##############################
        if (ObjectUtil.equal(namingStyle, NamingStyle.KEBAB_CASE)){
            // 串联命名
            return String.join(StrPool.DASHED, strList);
        } else if (ObjectUtil.equal(namingStyle, NamingStyle.SCREAMING_KEBAB_CASE)){
            // 大写串联命名
            return String.join(StrPool.DASHED, strList).toUpperCase();
        } else if (ObjectUtil.equal(namingStyle, NamingStyle.CAPITAL_KEBAB_CASE)){
            // 首字母大写串联命名
            return strList.stream().map(CharSequenceUtil::upperFirst)
                    .collect(Collectors.joining(StrPool.DASHED));
        }

        return null;
    }


}

功能测试

// 测试将 CaseFormatUtil 转换为 case_format_util
System.out.println(CaseFormatUtil.to("CaseFormatUtil", NamingStyle.SNAKE_CASE));