由于公司业务需要，大数据跑批筛选数据生成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
连字符的变量命名规范如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.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);
    }

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();
	}


}