下划线转驼峰，3种实现方式效率对比

想做一个数据格式转换的工具，恰好遇到了要把数据库中下划线字段改成java中驼峰型字符串，所以就去网上找点资料，并自己写了实现。

一时兴起想要比较一下效率如何，也顺便贴上代码。

总体而言，无论是驼峰转下划线还是下划线转驼峰，一般而言都不会超过5个毫秒，但是这个功能毕竟简单，积少成多之下，也会显得有些慢。鉴于毫秒的精度不够，我采用纳秒来量化执行效率。

结论是：

1.在使用java自带的正则表达式工具Pattern和Matcher的情况下，耗时非常大，最少也要约300万纳秒约合3毫秒才能完成，而基于字符串split或者replace，一般只需要70万纳秒约合0.7毫秒。但是正则工具的代码结构逻辑简单，而基于字符串的拆分和替换操作看起来有较多for和if而有些混乱。

2.基于StringBuilder进行字符串append效率和基于String的字符串拼接，在当前场合下效率差距不大，多数情况下两者都有时间波动偶尔有较大波动，可能和执作的时候CPU时间片分配有关。

3.此后的执行时间从5万纳秒到4万纳秒递减，与第一次时间差距非常大，应该是字符串常量池此时起了作用。速度非常快。

4.综合而言，从下划线转化为驼峰，比较快的情况稳定在50w纳秒左右，而从驼峰转化为下划线，耗时大大减少，比较快的情况下不到10万纳秒，常量池其作用后，耗时不足1w纳秒，相当于几个微秒就完成了。

环境信息：I5-6300HQ，12GDDR3内存，win10家庭版。

代码如下：实践证明这种小功能测效率纯粹是闲的蛋疼……

package json.util;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * Created by tm on 2016/11/24.
 * time : 15:45
 * project_name : code
 */
public class UnderLineString2Camel {
    /**
     * 下划线转驼峰
     * @param underline
     * @return
     */
    public static String underline2Camel(String underline){
        Pattern pattern = Pattern.compile("[_]\w");
        String camel = underline.toLowerCase();
        Matcher matcher = pattern.matcher(camel);
        while(matcher.find()){
            String w = matcher.group().trim();
            camel = camel.replace(w,w.toUpperCase().replace("_", ""));
        }
        return camel;
    }
    /**
     * 驼峰转下划线
     * @param camel
     * @return
     */
    public static String Camel2Underline(String camel){
        Pattern pattern = Pattern.compile("[A-Z]");
        Matcher matcher = pattern.matcher(camel);
        while(matcher.find()){
            String w = matcher.group().trim();
            camel = camel.replace(w,"_"+w);
        }
        return camel.toUpperCase();
    }
    /**
     * 驼峰转下划线。
     * @param camel
     * @return
     */
    public static String Camel2Underline2(String camel){
       char[] chars = camel.toCharArray();
       StringBuilder sb = new StringBuilder();
       for(int i=0,j=0;i<chars.length;i++,j++){
           char s = chars[i];
           if(s+1>65 && s+1<91){
               char _ = 95;
               sb.append(_);
               j++;
               sb.append(s);
               continue;
           }
           sb.append(s);
       }
        return sb.toString().toUpperCase();
    }
    public static void main(String[] args) {
        for (int i = 0;i<10;i++) {
            long start = System.nanoTime();
            camelNamesb("QW_ABD_XYZN");
            System.out.println(System.nanoTime() - start);
        }
    }
    public static String camelName(String name) {
        String  result = "";
        // 快速检查
        if (name == null || name.isEmpty()) {
            // 没必要转换
            return "";
        } else if (!name.contains("_")) {
            // 不含下划线，仅将首字母小写
            return name.substring(0, 1).toLowerCase() + name.substring(1);
        }
        // 用下划线将原始字符串分割
        String camels[] = name.split("_");
        for (String camel :  camels) {
            // 跳过原始字符串中开头、结尾的下换线或双重下划线
            if (camel.isEmpty()) {
                continue;
            }
            // 处理真正的驼峰片段
            if (result.length() == 0) {
                // 第一个驼峰片段，全部字母都小写
                result+=camel.toLowerCase();
            } else {
                // 其他的驼峰片段，首字母大写
                result+=camel.substring(0, 1).toUpperCase();
                result+=camel.substring(1).toLowerCase();
            }
        }
        return result;
    }
    public static String camelNamesb(String name) {
        StringBuilder sb = new StringBuilder();
        // 快速检查
        if (name == null || name.isEmpty()) {
            // 没必要转换
            return "";
        } else if (!name.contains("_")) {
            // 不含下划线，仅将首字母小写
            return name.substring(0, 1).toLowerCase() + name.substring(1);
        }
        // 用下划线将原始字符串分割
        String camels[] = name.split("_");
        for (String camel :  camels) {
            // 跳过原始字符串中开头、结尾的下换线或双重下划线
            if (camel.isEmpty()) {
                continue;
            }
            // 处理真正的驼峰片段
            if (sb.length() == 0) {
                // 第一个驼峰片段，全部字母都小写
                sb.append(camel.toLowerCase());
            } else {
                // 其他的驼峰片段，首字母大写
                sb.append(camel.substring(0, 1).toUpperCase());
                sb.append(camel.substring(1).toLowerCase());
            }
        }
        return sb.toString();
    }
    public static String underscoreName(String name) {
        StringBuilder result = new StringBuilder();
        if (name != null && name.length() > 0) {
            // 将第一个字符处理成大写
            result.append(name.substring(0, 1).toUpperCase());
            // 循环处理其余字符
            for (int i = 1; i < name.length(); i++) {
                String s = name.substring(i, i + 1);
                // 在大写字母前添加下划线
                if (s.equals(s.toUpperCase()) && !Character.isDigit(s.charAt(0))) {
                    result.append("_");
                }
                // 其他字符直接转成大写
                result.append(s.toUpperCase());
            }
        }
        return result.toString();
    }
    public static String camelToUnderline(String param){
        if (param==null||"".equals(param.trim())){
            return "";
        }
        int len=param.length();
        StringBuilder sb=new StringBuilder(len);
        for (int i = 0; i < len; i++) {
            char c=param.charAt(i);
            if (Character.isUpperCase(c)){
                sb.append("_");
                sb.append(Character.toLowerCase(c));
            }else{
                sb.append(c);
            }
        }
        return sb.toString();
    }
}

代码来自：

http://www.oschina.net/code/snippet_999605_24793 

http://blog.csdn.net/xiejx618/article/details/30129851 

来自为知笔记(Wiz)