下划线转驼峰，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家庭版。
代码如下：实践证明这种小功能测效率纯粹是闲的蛋疼……
  1. package json.util;
  3. import java.util.Arrays;
  4. import java.util.regex.Matcher;
  5. import java.util.regex.Pattern;
  7. /**
  8.  * Created by tm on 2016/11/24.
  9.  * time : 15:45
  10.  * project_name : code
  11.  */
  12. public class UnderLineString2Camel {
  14.     /**
  15.      * 下划线转驼峰
  16.      * @param underline
  17.      * @return
  18.      */
  19.     public static String underline2Camel(String underline){
  20.         Pattern pattern = Pattern.compile("[_]\\w");
  21.         String camel = underline.toLowerCase();
  22.         Matcher matcher = pattern.matcher(camel);
  23.         while(matcher.find()){
  24.             String w = matcher.group().trim();
  25.             camel = camel.replace(w,w.toUpperCase().replace("_", ""));
  26.         }
  27.         return camel;
  28.     }
  30.     /**
  31.      * 驼峰转下划线
  32.      * @param camel
  33.      * @return
  34.      */
  35.     public static String Camel2Underline(String camel){
  36.         Pattern pattern = Pattern.compile("[A-Z]");
  37.         Matcher matcher = pattern.matcher(camel);
  38.         while(matcher.find()){
  39.             String w = matcher.group().trim();
  40.             camel = camel.replace(w,"_"+w);
  41.         }
  42.         return camel.toUpperCase();
  43.     }
  45.     /**
  46.      * 驼峰转下划线。
  47.      * @param camel
  48.      * @return
  49.      */
  50.     public static String Camel2Underline2(String camel){
  51.        char[] chars = camel.toCharArray();
  52.        StringBuilder sb = new StringBuilder();
  53.        for(int i=0,j=0;i<chars.length;i++,j++){
  54.            char s = chars[i];
  55.            if(s+1>65 && s+1<91){
  56.                char _ = 95;
  57.                sb.append(_);
  58.                j++;
  59.                sb.append(s);
  60.                continue;
  61.            }
  62.            sb.append(s);
  63.        }
  64.         return sb.toString().toUpperCase();
  65.     }
  69.     public static void main(String[] args) {
  71.         for (int i = 0;i<10;i++) {
  72.             long start = System.nanoTime();
  73.             camelNamesb("QW_ABD_XYZN");
  74.             System.out.println(System.nanoTime() - start);
  75.         }
  76.     }
  79.     public static String camelName(String name) {
  80.         String  result = "";
  81.         // 快速检查
  82.         if (name == null || name.isEmpty()) {
  83.             // 没必要转换
  84.             return "";
  85.         } else if (!name.contains("_")) {
  86.             // 不含下划线，仅将首字母小写
  87.             return name.substring(0, 1).toLowerCase() + name.substring(1);
  88.         }
  89.         // 用下划线将原始字符串分割
  90.         String camels[] = name.split("_");
  91.         for (String camel :  camels) {
  92.             // 跳过原始字符串中开头、结尾的下换线或双重下划线
  93.             if (camel.isEmpty()) {
  94.                 continue;
  95.             }
  96.             // 处理真正的驼峰片段
  97.             if (result.length() == 0) {
  98.                 // 第一个驼峰片段，全部字母都小写
  99.                 result+=camel.toLowerCase();
  100.             } else {
  101.                 // 其他的驼峰片段，首字母大写
  102.                 result+=camel.substring(0, 1).toUpperCase();
  103.                 result+=camel.substring(1).toLowerCase();
  104.             }
  105.         }
  106.         return result;
  107.     }
  109.     public static String camelNamesb(String name) {
  110.         StringBuilder sb = new StringBuilder();
  111.         // 快速检查
  112.         if (name == null || name.isEmpty()) {
  113.             // 没必要转换
  114.             return "";
  115.         } else if (!name.contains("_")) {
  116.             // 不含下划线，仅将首字母小写
  117.             return name.substring(0, 1).toLowerCase() + name.substring(1);
  118.         }
  119.         // 用下划线将原始字符串分割
  120.         String camels[] = name.split("_");
  121.         for (String camel :  camels) {
  122.             // 跳过原始字符串中开头、结尾的下换线或双重下划线
  123.             if (camel.isEmpty()) {
  124.                 continue;
  125.             }
  126.             // 处理真正的驼峰片段
  127.             if (sb.length() == 0) {
  128.                 // 第一个驼峰片段，全部字母都小写
  129.                 sb.append(camel.toLowerCase());
  130.             } else {
  131.                 // 其他的驼峰片段，首字母大写
  132.                 sb.append(camel.substring(0, 1).toUpperCase());
  133.                 sb.append(camel.substring(1).toLowerCase());
  134.             }
  135.         }
  136.         return sb.toString();
  137.     }
  139.     public static String underscoreName(String name) {
  140.         StringBuilder result = new StringBuilder();
  141.         if (name != null && name.length() > 0) {
  142.             // 将第一个字符处理成大写
  143.             result.append(name.substring(0, 1).toUpperCase());
  144.             // 循环处理其余字符
  145.             for (int i = 1; i < name.length(); i++) {
  146.                 String s = name.substring(i, i + 1);
  147.                 // 在大写字母前添加下划线
  148.                 if (s.equals(s.toUpperCase()) && !Character.isDigit(s.charAt(0))) {
  149.                     result.append("_");
  150.                 }
  151.                 // 其他字符直接转成大写
  152.                 result.append(s.toUpperCase());
  153.             }
  154.         }
  155.         return result.toString();
  156.     }
  158.     public static String camelToUnderline(String param){
  159.         if (param==null||"".equals(param.trim())){
  160.             return "";
  161.         }
  162.         int len=param.length();
  163.         StringBuilder sb=new StringBuilder(len);
  164.         for (int i = 0; i < len; i++) {
  165.             char c=param.charAt(i);
  166.             if (Character.isUpperCase(c)){
  167.                 sb.append("_");
  168.                 sb.append(Character.toLowerCase(c));
  169.             }else{
  170.                 sb.append(c);
  171.             }
  172.         }
  173.         return sb.toString();
  174.     }
  175. }
代码来自：




posted @ 2016-11-24 18:14  open_sesame  Views(6777)  Comments(0)    收藏  举报