根据定界符分割字符串，并根据定界符计数转换为n级对

Question

有一个哈希表，下面是要求：

<p>
  <a href="grodzi">grodzi</a>
  <a href="laaaa">LAAAA</a>
</p>

1. 获取哈希表的所有记录并对其进行迭代
2. 基于定界符分割密钥，并将其转换为Pair或Hashmap
3. 每个字符串中定界符的数量将有所不同

下面应该是输出：

    Map<String, Object> objectmetainfo = new HashMap();
    objectmetainfo.put("userdetails.info.metadata.user.home.address.details", "address");
    objectmetainfo.put("userdetails.info.metadata.user.id", "id");
    objectmetainfo.put("userdetails.info.metadata.userSupervisor.id", "id");
    objectmetainfo.put("info.metadata.code", "code");
    objectmetainfo.put("zip", "zip");

Answer 1

假设您的字符串不会太疯狂，那么它会起作用，否则您会收到StackOverflow错误。l

我使用递归方法

1. 按“。”分隔键。
2. 将它们转换为列表迭代器
3. 递归地迭代此列表以创建嵌套地图
4. 在递归末尾放置objectmetainfo映射中的值。
5. 创建一个空的结果图并递归合并所有结果。

代码：

import java.util.*;
    public Map<String, Object> nestedMaps(Iterator<String> keys, String value) {
        if (keys.hasNext()) {
            String key = keys.next();
            Map<String, Object> nestMap = nestedMaps(keys, value);
            Map<String, Object> map = new HashMap<>();
            map.put(key, nestMap);
            if (Objects.equals(nestMap, null))
                map.put(key, value);
            return map;
        }
        return null;
    }
    public void mergeNested(Object srcObj, Object targetObj) {
        if (srcObj instanceof Map && targetObj instanceof Map) {
            Map<String, Object> srcMap = (Map<String, Object>) srcObj;
            Map<String, Object> targetMap = (Map<String, Object>) targetObj;
            for (String targetKey : targetMap.keySet()) {
                if (srcMap.containsKey(targetKey)) {
                    mergeNested(srcMap.get(targetKey), targetMap.get(targetKey));
                } else {
                    srcMap.putAll(targetMap);
                }
            }
        }

    }
    public Map<String, Object> objectmetainfo = new LinkedHashMap<>();
    objectmetainfo.put("userdetails.info.metadata.user.home.address.details", "addressValue");
    objectmetainfo.put("userdetails.info.metadata.user.id", "id");
    objectmetainfo.put("userdetails.info.metadata.userSupervisor.id", "id");
    objectmetainfo.put("info.metadata.code", "code");
    objectmetainfo.put("zip", "zip");

    public Map<String, Object> result = new HashMap<>();
    for (Map.Entry<String, Object> e : objectmetainfo.entrySet()) {
        List<String> keys = new ArrayList<>(Arrays.asList(e.getKey().split("\\.")));
        Map<String, Object> nestedMaps = nestedMaps(keys.iterator(), String.valueOf(e.getValue()));
        mergeNested(result, nestedMaps);
    }
    System.out.println(result);

我使用toString方法打印了所有哈希图。 输出：

{
    zip= zip,
    userdetails= {
        info= {
            metadata= {
                userSupervisor= {
                    id= id
                },
                user= {
                    id= id,
                    home= {
                        address= {
                            details= addressValue
                        }
                    }
                }
            }
        }
    },
    info= {
        metadata= {
            code= code
        }
    }
}

Answer 2

下面是修改后的逻辑，用于删除第二个递归调用，使用此方法，我们将objMap作为参考传递，最后我们将准备好objMap及其结果

Map<String, Object> objMap = new HashMap<>();
        for (Map.Entry<String, Object> e : getObjectMetaInfoMap().entrySet()) {
            populateMetaDataMap(keys.iterator(), String.valueOf(e.getValue()), objMap, true, StringUtils.EMPTY);            
        }

public static Map<String, Object> populateMetaDataMap(Iterator<String> keys, String value, Map<String, Object> objMap, boolean newCall, String matchingKey) {
        if (keys.hasNext()) {
            String key = keys.next();
            if(objMap.get(key) != null && objMap.get(key) instanceof Map) {
                return populateMetaDataMap(keys, value, (Map<String, Object>) objMap.get(key), newCall, matchingKey );
            } else  {
                if(newCall) {
                    newCall = false;
                    matchingKey = key;
                }
                Map<String, Object> nestMap = populateMetaDataMap(keys, value, objMap, newCall, matchingKey);
                Map<String, Object> map = new HashMap<>();
                if (Objects.equals(nestMap, null))
                    map.put(key, value);
                else
                    map.put(key, nestMap);

                if(key.equals(matchingKey)) {
                    if(Objects.equals(nestMap, null)) {
                        objMap.put(key, value);
                    } else {
                        objMap.put(key, nestMap);
                    }
                }
                return map;
            }
        }
        return null;
    }