java中如何快速优雅的把一个对象的属性赋值到另一个对象中（驼峰-＞驼峰，驼峰-＞下划线，下划线-＞驼峰）

古城微笑少年丶 2023-10-07 15:19 46阅读 0赞

#### java中如何快速优雅的把一个对象的属性赋值到另一个对象中（驼峰->驼峰，驼峰->下划线，下划线->驼峰） ####

*   *  一、驼峰->驼峰
     *  二、驼峰->下划线，下划线->驼峰

在工作中，我们经常会遇到对象之间赋值的问题，例如把ObjectA赋值到ObjectB中，最原始的方式就是每个属性都通过get/set去取值赋值。这样就使得我们的代码出现了大量的低效代码，降低了整体代码的质量。

### 一、驼峰->驼峰 ###

正常我们java类中的属性变量都是以驼峰形式命名的，对于两个对象一样的属性，我们可以通过Spring中的BeanUtils.copyProperties(A,B)快速把A的属性赋值到B的属性中，然后剩下个别不一样的属性再get/set，就会简化很多代码。

### 二、驼峰->下划线，下划线->驼峰 ###

我们有时候与第三方平台对接的时候，可能会有这种情况：我们这边的是驼峰命名的变量，而第三方则是下划线命名的变量（或者我们是下划线，第三方是驼峰）。这样就导致很尴尬，在接他们的对象或传值给他们时，都要手动去转换对象，代码块中全是get/set代码。我这边封装了一个工具类，供大家参考，主要思路就是map与对象之间互转，并且for循环map把每个key转成下划线（或驼峰）。代码如下：

CovertUtil工具类：

/**
     * ConvertUtil 转换工具类
     */
    public class ConvertUtil {
        
    
        /**
         * 驼峰对象转换为下划线对象
         * @param source 驼峰对象
         * @param target 下划线对象
         * @return
         */
        public static void humpObj2UlObj(Object source, Object target) {
        
            Map<String,Object> map1 = obj2Map(source);
            Map<String,Object> map2 = new HashMap<>();
            for(String key : map1.keySet()){
        
                map2.put(hump2Ul(key),map1.get(key));
            }
            Object obj = map2Obj(map2, target.getClass());
            BeanUtils.copyProperties(obj,target);
        }
    
        /**
         * 下划线对象转换为驼峰对象
         * @param source 下划线对象
         * @param target 驼峰对象
         * @return
         */
        public static void ulObj2HumpObj(Object source, Object target) {
        
            Map<String,Object> map1 = obj2Map(source);
            Map<String,Object> map2 = new HashMap<>();
            for(String key : map1.keySet()){
        
                map2.put(ul2Hump(key),map1.get(key));
            }
            Object obj = map2Obj(map2, target.getClass());
            BeanUtils.copyProperties(obj,target);
        }
    
        /**
         * 实体对象转成Map
         * @param obj
         * @return
         */
        public static Map<String, Object> obj2Map(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 map2Obj(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 hump2Ul(String str){
        
            StringBuilder sb=new StringBuilder(str);
            int temp=0;
            if (!str.contains("_")) {
        
                for(int i=0;i<str.length();i++){
        
                    if(Character.isUpperCase(str.charAt(i))){
        
                        sb.insert(i+temp, "_");
                        temp+=1;
                    }
                }
            }
            return sb.toString().toLowerCase();
        }
    
        /**
         * [字符串]下划线转驼峰
         * @param str
         * @return
         */
        public static String ul2Hump(String str){
        
            StringBuilder result=new StringBuilder();
            String a[]=str.split("_");
            for(String s:a){
        
                if (!str.contains("_")) {
        
                    result.append(s);
                    continue;
                }
                if(result.length()==0){
        
                    result.append(s.toLowerCase());
                }else{
        
                    result.append(s.substring(0, 1).toUpperCase());
                    result.append(s.substring(1).toLowerCase());
                }
            }
            return result.toString();
        }
    }

A类（驼峰）：

@Data
    public class TestA {
        
        private String parkId;
        private String parkName;
        private String carNo;
        private String inTime;
        private String outTime;
    }

B类（下划线）：

@Data
    public class TestB {
        
        private String park_id;
        private String park_name;
        private String car_no;
        private String in_time;
        private String out_time;
    }

使用示例（驼峰->下划线）：

public static void main(String[] args) {
        
        TestA a = getInstanceA();
        TestB b = new TestB();
        ConvertUtil.humpObj2UlObj(a,b);
        System.out.println(b.toString());
    }

使用示例（下划线->驼峰）：

public static void main(String[] args) {
        
        TestB b = getInstanceB();
        TestA a = new TestA();
        ConvertUtil.ulObj2HumpObj(b,a);
        System.out.println(a.toString());
    }