字符转驼峰写法

问题：

最近在业务上碰到一个比较坑的问题，技术上采用mybatis-plus实现数据操作，因为懒得写xml配置文件，而且需要查询的表的字段太多，手写太麻烦，但是因为时间问题，没有很好的解决，如下写法一直被我诟病。

 QueryWrapper<DlOrder> queryWrapper = new QueryWrapper<DlOrder>();
 queryWrapper.select("id,create_user as createUser,created_ip createdIp," +
   			"created_time createdTime,day,is_delete isDelete,lockversion,month," +
             	"update_time updateTime,year,...");
 List<Map<String, Object>> records = dlOrderService.selectMaps(queryWrapper);

这样的下场可想而知，就是需要将每个字段重命名，否则每个Map的key值都会出现带有下划线的字段，一旦字段太多，可想而知写法不美观，还影响效率，阅读和使用的时候是非常不方便的。另外，你们可能发现为啥不采用直接转对象的查询方法呢？这是因为业务需要查询，可能出现非本表的字段，这样就没办法用查询对象的列表方法了。在网上一顿查阅，发现了其实Apache已经提供了相应的架包和相应的方法，这边偷懒不想增加额外的架包，因此，把它核心代码拷贝下来，以供后续学习利用。

代码

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;

/**
 * apache源码
 * 功能：将特定元素转为指定元素
 * 如将map中key值带下划线转为驼峰写法的key值:car_no => carNo
 */
public class CaseUtils {

    /**
     * <p>{@code CaseUtils} instances should NOT be constructed in
     * standard programming. Instead, the class should be used as
     * {@code CaseUtils.toCamelCase("foo bar", true, new char[]{'-'});}.</p>
     *
     * <p>This constructor is public to permit tools that require a JavaBean
     * instance to operate.</p>
     */
    public CaseUtils() {
        super();
    }

    /**
     * <p>Converts all the delimiter separated words in a String into camelCase,
     * that is each word is made up of a title case character and then a series of
     * lowercase characters.</p>
     *
     * <p>The delimiters represent a set of characters understood to separate words.
     * The first non-delimiter character after a delimiter will be capitalized. The first String
     * character may or may not be capitalized and it's determined by the user input for capitalizeFirstLetter
     * variable.</p>
     *
     * <p>A {@code null} input String returns {@code null}.
     * Capitalization uses the Unicode title case, normally equivalent to
     * upper case and cannot perform locale-sensitive mappings.</p>
     *
     * <pre>
     * CaseUtils.toCamelCase(null, false)                                 = null
     * CaseUtils.toCamelCase("", false, *)                                = ""
     * CaseUtils.toCamelCase(*, false, null)                              = *
     * CaseUtils.toCamelCase(*, true, new char[0])                        = *
     * CaseUtils.toCamelCase("To.Camel.Case", false, new char[]{'.'})     = "toCamelCase"
     * CaseUtils.toCamelCase(" to @ Camel case", true, new char[]{'@'})   = "ToCamelCase"
     * CaseUtils.toCamelCase(" @to @ Camel case", false, new char[]{'@'}) = "toCamelCase"
     * </pre>
     *
     * @param str  the String to be converted to camelCase, may be null
     * @param capitalizeFirstLetter boolean that determines if the first character of first word should be title case.
     * @param delimiters  set of characters to determine capitalization, null and/or empty array means whitespace
     * @return camelCase of String, {@code null} if null String input
     */
    public static String toCamelCase(String str, final boolean capitalizeFirstLetter, final char... delimiters) {
        if (StringUtils.isEmpty(str)) {
            return str;
        }
        str = str.toLowerCase();
        final int strLen = str.length();
        final int[] newCodePoints = new int[strLen];
        int outOffset = 0;
        final Set<Integer> delimiterSet = generateDelimiterSet(delimiters);
        boolean capitalizeNext = false;
        if (capitalizeFirstLetter) {
            capitalizeNext = true;
        }
        for (int index = 0; index < strLen;) {
            final int codePoint = str.codePointAt(index);

            if (delimiterSet.contains(codePoint)) {
                capitalizeNext = outOffset != 0;
                index += Character.charCount(codePoint);
            } else if (capitalizeNext || outOffset == 0 && capitalizeFirstLetter) {
                final int titleCaseCodePoint = Character.toTitleCase(codePoint);
                newCodePoints[outOffset++] = titleCaseCodePoint;
                index += Character.charCount(titleCaseCodePoint);
                capitalizeNext = false;
            } else {
                newCodePoints[outOffset++] = codePoint;
                index += Character.charCount(codePoint);
            }
        }
        if (outOffset != 0) {
            return new String(newCodePoints, 0, outOffset);
        }
        return str;
    }

    /**
     * <p>Converts an array of delimiters to a hash set of code points. Code point of space(32) is added
     * as the default value. The generated hash set provides O(1) lookup time.</p>
     *
     * @param delimiters  set of characters to determine capitalization, null means whitespace
     * @return Set<Integer>
     */
    private static Set<Integer> generateDelimiterSet(final char[] delimiters) {
        final Set<Integer> delimiterHashSet = new HashSet<>();
        delimiterHashSet.add(Character.codePointAt(new char[]{' '}, 0));
        if (ArrayUtils.isEmpty(delimiters)) {
            return delimiterHashSet;
        }

        for (int index = 0; index < delimiters.length; index++) {
            delimiterHashSet.add(Character.codePointAt(delimiters, index));
        }
        return delimiterHashSet;
    }

    public static void main(String[] args) {
        HashMap<String,Object> sourceMap = new HashMap<>();
        sourceMap.put("user_id", 1);
        sourceMap.put("user_name","hello");
        sourceMap.put("_car_no", "闽A12345");
        HashMap targetMap = new HashMap();
        for (Map.Entry<String, Object> entry : sourceMap.entrySet()) {
            targetMap.put(CaseUtils.toCamelCase(entry.getKey(), false, new char[]{'_'}), entry.getValue());
        }
        targetMap.keySet().stream().forEach(System.out::println);
    }
}

这边只是提供最核心的代码，如果需要可自行修改符合业务的代码场景，如果有任何疑问可留言。