精华内容
下载资源
问答
  • JAVA驼峰下划线转换

    2019-07-11 17:35:35
    读取的数据字段名是数据库字段,下划线格式的,需要转换驼峰的,所以写了一个小小的工具类。 private static final String SPLIT_SYMBOL = "_"; /** * Created by Li hongxin on 2019/6/19 1...
    由于公司业务需要,大数据跑批筛选数据生成CSV文件放到sftp服务器,然后这边定时拉取文件解析数据进行入库并推送到下游
    读取的数据字段名是数据库字段,下划线格式的,需要转换为驼峰的,所以写了一个小小的工具类。
    
    private static final String SPLIT_SYMBOL = "_";
    /**
     * Created by Li hongxin on 2019/6/19 17:44
     * Desc : 下划线格式转换为驼峰格式
     * fileNames        要进行转换的数据
     * beanFieldsName   要转换到对象的对象名
     * @returns         返回驼峰格式的数据
     */
    private static void toCamelCase(ArrayList<String> fieldNames) {
    
        if (CollectionUtils.isEmpty(fieldNames)) {
            return;
        }
        for (int i = 0; i < fieldNames.size(); i++) {
            String fieldName = fieldNames.get(i);
            if (StringValidate.isNotBlank(fieldName)) {
                fieldName = fieldName.toLowerCase();
                if (fieldName.contains(SPLIT_SYMBOL)) {
                    String[] split = fieldName.split(SPLIT_SYMBOL);
                    String temp = split[0];
                    for (int j = 1; j < split.length; j++) {
                        String str = split[j];
                        temp = temp + str.substring(0, 1).toUpperCase() + str.substring(1, str.length());
                    }
                    fieldName = temp;
                }
                //使用驼峰格式替换下划线格式
                fieldNames.set(i, fieldName);
            }
        }
    }
    
    //去驼峰,转为下划线
    private static void deCamelCase(ArrayList<String> fieldNames) {
    
        if (CollectionUtils.isEmpty(fieldNames)) {
            return;
        }
        for (int i = 0; i < fieldNames.size(); i++) {
            String fieldName = fieldNames.get(i);
            if (StringValidate.isNotBlank(fieldName)) {
                //去空格
                fieldName = fieldName.replace(" ", "");
                //逐个字符遍历
                StringBuilder sb = new StringBuilder(16);
                for (Character chr : fieldName.toCharArray()) {
                    if (Character.isLetter(chr)) {
                        if (Character.isUpperCase(chr)) {
                            chr = Character.toLowerCase(chr);
                            sb.append(SPLIT_SYMBOL).append(chr);
                        } else {
                            sb.append(chr);
                        }
                    } else {
                        sb.append(chr);
                    }
                }
                fieldName = sb.toString().toUpperCase();
                //使用驼峰格式替换下划线格式
                fieldNames.set(i, fieldName);
            }
        }
    }
    
    展开全文
  • 工具类需要依赖谷歌的java开发工具包guava,这个工具包里面具备了很多功能具体的可以参考关于guava的系列教程 CaseFomat提供的枚举常量的说明 SN 枚举常量 说明 1 LOWER_HYPHEN 连字符的变量命名规范如...

    此工具类需要依赖谷歌的java开发工具包guava,这个工具包里面具备了很多功能具体的可以参考关于guava的系列教程

    CaseFomat提供的枚举常量的说明

    SN 枚举常量 说明
    1 LOWER_HYPHEN 连字符的变量命名规范如lower-hyphen
    2 LOWER_UNDERSCORE c++变量命名规范如lower_underscore
    3 LOWER_CAMEL java变量命名规范如lowerCamel
    4 UPPER_CAMEL java和c++类的命名规范如UpperCamel
    5 UPPER_UNDERSCORE java和c++常量的命名规范如UPPER_UNDERSCORE

    maven依赖

    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>21.0</version>
    </dependency>
    
    import org.junit.Test;
    
    import com.google.common.base.CaseFormat;
    
    public class GuavaTester {
    
        @Test
        public void test() {
            System.out.println(CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, "test-data"));//testData
            System.out.println(CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, "test_data"));//testData
            System.out.println(CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, "test_data"));//TestData
    
            System.out.println(CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, "testdata"));//testdata
            System.out.println(CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, "TestData"));//test_data
            System.out.println(CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN, "testData"));//test-data
    
        }
    }
    
    展开全文
  • import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; import com.google.common.collect.Lists; import com.google.common.collect.Maps... import java.lang.reflect.Field;...import java.l...
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import com.google.common.collect.Lists;
    import com.google.common.collect.Maps;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.Modifier;
    import java.util.*;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    /**
     * <p>
     * ConvertUtil 转换工具类
     * </p>
     *
     * @author lut
     * @since 2019.5.02
     */
    public class ConvertUtil {
    
        private static Pattern linePattern = Pattern.compile("_([a-z])");
    
        private static Pattern humpPattern = Pattern.compile("\\B(\\p{Upper})(\\p{Lower}*)");
    
        /**
         * 实体对象转成Map
         *
         * @param obj 实体对象
         * @return
         */
        public static Map<String, Object> object2Map(Object obj) {
            Map<String, Object> map = new HashMap<>();
            if (obj == null) {
                return map;
            }
            @SuppressWarnings("rawtypes")
            Class clazz = obj.getClass();
            Field[] fields = clazz.getDeclaredFields();
            try {
                for (Field field : fields) {
                    field.setAccessible(true);
                    map.put(field.getName(), field.get(obj));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return map;
        }
    
        /**
         * Map转成实体对象
         *
         * @param map   map实体对象包含属性
         * @param clazz 实体对象类型
         * @return
         */
        public static Object map2Object(Map<String, Object> map, Class<?> clazz) {
            if (map == null) {
                return null;
            }
            Object obj = null;
            try {
                obj = clazz.newInstance();
    
                Field[] fields = obj.getClass().getDeclaredFields();
                for (Field field : fields) {
                    int mod = field.getModifiers();
                    if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
                        continue;
                    }
                    field.setAccessible(true);
                    field.set(obj, map.get(field.getName()));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return obj;
        }
    
    
        /**
         * 下划线转驼峰
         *
         * @param str
         * @return
         */
        public static String lineToHump(String str) {
            Matcher matcher = linePattern.matcher(str);
            StringBuffer sb = new StringBuffer();
            while (matcher.find()) {
                matcher.appendReplacement(sb, matcher.group(1).toUpperCase());
            }
            matcher.appendTail(sb);
            return sb.toString();
        }
    
    
        /**
         * 驼峰转下划线(Map)
         *
         * @param str
         * @return
         */
        public static String humpToLine(String str) {
            Map<String, Object> map = JSONObject.parseObject(str);
            Map<String, Object> newMap = Maps.newHashMap();
            Iterator<Map.Entry<String, Object>> it = map.entrySet().iterator();
            while (it.hasNext()) {
                StringBuffer sb = new StringBuffer();
                Map.Entry<String, Object> entry = it.next();
                String key = entry.getKey();
                Matcher matcher = humpPattern.matcher(key);
                while (matcher.find()) {
                    matcher.appendReplacement(sb, "_" + matcher.group(0).toLowerCase());
                }
                matcher.appendTail(sb);
                newMap.put(sb.toString(), entry.getValue());
            }
            return JSON.toJSONString(newMap);
    
        }
    
        /**
         * 驼峰转下划线(List)
         *
         * @param str
         * @return
         */
        @SuppressWarnings("all")
        public static String humpToLineList(String str) {
            List<Map> list = JSONObject.parseArray(str, Map.class);
            List<Map<String, Object>> res = new ArrayList<>();
            list.stream().forEach(p -> {
                Map<String, Object> newMap = Maps.newHashMap();
                Iterator<Map.Entry<String, Object>> it = p.entrySet().iterator();
                while (it.hasNext()) {
                    StringBuffer sb = new StringBuffer();
                    Map.Entry<String, Object> entry = it.next();
                    String key = entry.getKey();
                    Matcher matcher = humpPattern.matcher(key);
                    while (matcher.find()) {
                        matcher.appendReplacement(sb, "_" + matcher.group(0).toLowerCase());
                    }
                    matcher.appendTail(sb);
                    newMap.put(sb.toString(), entry.getValue());
                }
                res.add(newMap);
            });
            return JSON.toJSONString(res);
        }
    展开全文
  • * 将驼峰式命名的字符串转换下划线大写方式。如果转换前的驼峰式命名的字符串为空,则返回空字符串。</br> * 例如:HelloWorld->HELLO_WORLD * @param name 转换前的驼峰式命名的字符串 * @return ...
    package com.zycfc.mpc.process.util;
    public class HumpLineUtils {
    	public static void main(String[] args) {
    		System.out.println(transline("helloworld","Lower"));
    	}
    	/**	 
    	 * 例如:helloWorld->hello_world
    	 */
    	public static String transline(String name,String type) {
    	    StringBuilder result = new StringBuilder();
    	    if (name != null && name.length() > 0) {
    	        // 循环处理其余字符
    	        for (int i = 0; i < name.length(); i++) {
    	        	if(i==0&&"Lower".equals(type)) {
    	    	        result.append(name.substring(0, 1).toLowerCase());
    	    	        continue;
    	        	}
    	        	if(i==0) {
    	        	    result.append(name.substring(0, 1).toUpperCase());
    	    	        continue;
    	        	}
    	            String s = name.substring(i, i + 1);
    	            // 在大写字母前添加下划线
    	            if (s.equals(s.toUpperCase()) && !Character.isDigit(s.charAt(0))) {
    	                result.append("_");
    	            }
    	            //其他转化小写
    	            if("Lower".equals(type)) {
    	            	result.append(s.toLowerCase());
    	            	continue;
    	            }
    	            // 其他字符直接转成大写
    	            result.append(s.toUpperCase());
    	        }
    	    }
            return result.toString();
    	}
    	/**
    	 * hello_world-->helloWorld
    	 * 例如:HELLO_WORLD->HelloWorld
    	 */
    	public static String transHump(String name) {
    	    StringBuilder result = 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 (result.length() == 0) {
    	            // 第一个驼峰片段,全部字母都小写
    	            result.append(camel.toLowerCase());
    	        } else {
    	            // 其他的驼峰片段,首字母大写
    	            result.append(camel.substring(0, 1).toUpperCase());
    	            result.append(camel.substring(1).toLowerCase());
    	        }
    	    }
    	    return result.toString();
    	}
    
    
    }
    

     

    展开全文
  • 笔记一个工具类:驼峰下划线的写法互转import java.util.regex.Matcher;import java.util.regex.Pattern;public class Underline2Camel {/*** 下划线驼峰法* @param line 源字符串* @param smallCamel 大小驼峰,...
  • 博主是结合开源hutool ... * 转换驼峰格式/转换下划线方式 * * @param json 等待转换的方法 * @param upper 首字母大写或者小写 * @return 转换后的 */ public static JSONObject formatKey(final JSO.
  • 背景 将数据库字段映射到Java实体类时遇到的问题,如user_id需要映射成userId。 talk is cheap , show me the code ... * 将下划线命名转换驼峰式命名 * 例:user_id -> userId * ASCII表 *...
  • 下划线驼峰字符串的转换java接口开发过程中,文档定义是下划线,但是java bean的属性是驼峰,一个一个copy 修改太麻烦。 工具:notepad++ 下划线驼峰: 替换规则 :([a-z])_([a_z]) -->> \1\U\2\E ...
  • 前提:最近使用struts2+spring+hibernate集成框架做项目,突然从springmvc+...所以就想着把数据库大写加下划线格式(USER_TYPE)类型的key转成java熟悉的驼峰格式,就有了该文章的思路。 /** * 将Map中的ke...
  • 近期在写一个迷你型的mybaits框架,涉及到数据库字段映射到Java实体类时遇到的需要将下换线转命名成驼峰命名。... * @description: 下划线转换驼峰工具类 * @author: yanling * @time: 2021/1/2 */ public class To
  • package ... import jdk.nashorn.internal.runtime.regexp.joni.Regex; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.sql.ResultSet;...import java.sql.S...
  • 1、驼峰下划线方式名称互相转换工具类 public class CamelUnderlineUtil { private static final char UNDERLINE ='_'; public static String camelToUnderline(String param) { if (StringUtil.isEmpty...
  • 把数据库字段名转换驼峰命名,如:create_time 转换为: createTime。方便在写mapper文件时使用,特别是进行insert操作时 import org.apache.commons.io.FileUtils; import java.io.File; import java.io....
  • 背景:因顺丰快递API的HTTP传输格式为JSON,且属性为下划线风格(如图二),但JAVA实体类属性名称遵循了驼峰规范,故写了一个工具类,作为转换。   package com.imall.crm; import ...
  • 一、概念介绍 1.1、匈牙利命名法:user_id,字母均小写,不同单词间用下划线分割; 1.2、驼峰命名法:userId,除了第一个...如何将匈牙利命名法转换驼峰命名法? 三、思路 这里有好几种方法,这里介绍一种...
  • 一、概念介绍1.1、匈牙利命名法:user_id,字母均小写,不同单词间用下划线分割;...二、问题如何将匈牙利命名法转换驼峰命名法?三、思路这里有好几种方法,这里介绍一种:1.首先我们要获取匈牙利命名法的 ...
  • 下划线驼峰命名 是否包含字符串 注: 博客:https://blog.csdn.net/badao_liumang_qizhi 关注公众号 霸道的程序猿 获取编程相关电子书、教程推送与免费下载。 实现 新建工具类StringUtils import java.util...
  • java基础工具类iceroot

    2017-04-30 21:34:11
    java基础工具类iceroot iceroot是一个java基础工具类.封装了很多有用的方法. 该类库无任何第三方依赖. ...驼峰下划线互转 执行命令行 反射调用方法 集合操作 日期格式化与解析 时分秒转换 uuid生成 常用的常量 执行sql
  • 字段名转换驼峰文件名和下划线文件名相互转换工具类package com.git.easyloan.netloan.entity.util;public class FormatConversion {public static String humpToUnderline(String name) {StringBuilder result ...
  • 驼峰文件名和下划线文件名相互转换工具类 package com.git.easyloan.netloan.entity.util; public class FormatConversion { public static String humpToUnderline(String name) { StringBuilder result = ...
  • 实体字段的设计为小驼峰类型,数据库字段的设计遵循下划线分割设计对应字段设计的小驼峰原则。 例如实体中的字段为taskType,则数据库的字段为TASK_TYPE。 工具类代码如下: package com.company.utils; import...
  • Guava之CaseFormat

    2017-02-23 22:39:00
     从以上枚举中可以看出,java程序员最常用的转换类型为:UPPER_CAMEL,即我们常说的"驼峰式"编写方式;其次,我们常用的是:UPPER_UNDERSCORE,即我们常用的常量命名法,不同单词见使用下划线分割的书写方式。 ...
  • 添加是否下划线转换驼峰的选择(感谢@youngking28 的pull request). 2019.05.18 1.优化注释. 2.修改 mybatis模板中 controller注解. 3.修改 mybatis模板中 dao文件使用为 mapper文件. 4.修改 mybatis模板中 ...

空空如也

空空如也

1 2
收藏数 29
精华内容 11
关键字:

驼峰下划线转换工具java

java 订阅