Java将Map字段名由下划线转驼峰（多层嵌套，递归实现）

Java将Map字段名由下划线转驼峰（多层嵌套，递归实现）

背景

大家好，欢迎来到今天的技术播客。在今天的话题中，我们将讨论如何在Java中处理具有多层嵌套的Map数据结构，并将字段名从下划线格式转换为驼峰命名格式。这是一个在实际应用中非常常见的需求，因为我们经常需要与数据库或外部API返回的数据打交道，而这些数据通常以下划线分隔的字段名格式存储。

分析

首先，让我们分析一下这个问题。我们需要处理的情况是一个嵌套的Map，其中包含了字段名和相应的值。嵌套可能会非常深，因此我们需要一种递归方法来处理每个嵌套层次。为了实现这个目标，我们需要考虑以下几个关键点：

• 如何递归处理嵌套的Map。
• 如何将字段名由下划线格式转换为驼峰命名格式。
• 如何处理各种数据类型，包括基本类型和嵌套的Map。

目的

我们的目标是创建一个通用的工具，可以处理各种嵌套的Map，并将其中的字段名从下划线格式转换为驼峰命名格式。这将有助于简化代码，使其更易于理解和维护。我们的解决方案应该具备以下特点：

• 通用性：能够处理任何嵌套层次的Map。
• 灵活性：能够处理不同数据类型。
• 可维护性：易于理解和扩展。

最终实现的目的是：

{
	"name": "语音识别",
	"photo_url": "https://www.xxx.cn/edu_ai/3d473f22-53ad-4d2a-beee-30fabab2baca.png",
	"list": [{
		"id": 111,
		"list_name": "dsadas"
	}],
	"bean": {
		"id": 111,
		"bean_name": "dsadas"
	},
	"school_ids": [1110000001000000660, 1111111111111111]
}

讲这个json穿转为:

{
	"photoUrl": "https://bjdownload.cycore.cn/edu_ai/3d473f22-53ad-4d2a-beee-30fabab2baca.png",
	"schoolIds": ["1110000001000000660", "1111111111111111"],
	"name": "语音唤醒",
	"list": [{
		"id": 111,
		"listName": "dsadas"
	}],
	"bean": {
		"beanName": "dsadas",
		"id": 111
	}
}

源码

废话不多说，直接上代码:

public static Map<String, Object> getUnderToHump(Map<String, Object> map) {
        if (Objects.isNull(map)) {
            return map;
        }
        List<Map.Entry<String, Object>> list = map.entrySet().stream().collect(Collectors.toList());
        Map<String, Object> paramMap = new HashMap<>();
        for (Map.Entry<String, Object> entry : list) {
            if (entry.getKey().indexOf("_") == -1) {
                Object value = getValue(entry);
                paramMap.put(entry.getKey(), value);
                continue;
            }
            String[] split = entry.getKey().split("_");
            StringBuilder result = new StringBuilder();
            result.append(split[0]);
            for (int i=1;i<split.length;i++) {
                result.append(split[i].substring(0,1).toUpperCase()).append(split[i].substring(1));
            }
            paramMap.put(result.toString(), getValue(entry));
        }
        return paramMap;
    }

    private static Object getValue(Map.Entry<String, Object> entry) {
        Object value = entry.getValue();
        if (entry.getValue() instanceof List) {
            List listValue =(List) entry.getValue();
            List result = new ArrayList();
            for (Object o: listValue) {
                Object convert = null;
                if (o instanceof Map) {
                    Map mapList =(Map) o;
                    convert = getUnderToHump(mapList);
                }
                if (o instanceof Long) {
                    convert = String.valueOf(o);
                }
                result.add(convert);
            }
            value = result;
        }
        if (entry.getValue() instanceof Map) {
            Map linkedHashMap =(Map) entry.getValue();
            value = getUnderToHump(linkedHashMap);
        }
        if (entry.getValue() instanceof JsonArray) {
            JsonArray value1 = (JsonArray) entry.getValue();
            JsonArray transValue  = new JsonArray();
            for (JsonElement o:value1) {
                if (o instanceof JsonObject) {
                    JsonObject jsonObject =  o.getAsJsonObject();
                    Map underToHump = getUnderToHump(new Gson().fromJson(jsonObject.toString(), Map.class));
                    transValue.add(JsonParser.parseString(new Gson().toJson(underToHump)));
                } else {
                    transValue.add(o.toString());
                }
            }
            value = transValue;
        }
        if (entry.getValue() instanceof JsonObject) {
            JsonObject jsonObject  = (JsonObject) entry.getValue();
            value = getUnderToHump( new Gson().fromJson(jsonObject.toString(),Map.class));
        }
        return value;
    }

测试代码：

    public static void main(String[] args) {
        Map<String, Object> inputMap = new HashMap<>();
        inputMap.put("first_name", "John");
        inputMap.put("last_name", "Doe");

        Map<String, Object> addressMap = new HashMap<>();
        addressMap.put("address_line_1", "123 Main St");
        addressMap.put("address_line_2", "Apt 4B");

        inputMap.put("address_info", addressMap);

        Map<String, Object> result = getUnderToHump(inputMap);
        System.out.println(result);
    }

简单说下吧，其实思路很简单，就是一层一层的看，如果有多层接口，就递归调用getUnderToHump方法讲嵌套的字段给重新修改，最后再组合成新的map的key和value值。