将地图转换为嵌套地图

Question

我的 YamlFile 类上有这个映射，它以这种格式存储文件的所有键：String key = "firskey.secondkey.thirdkey", Object value = "Example value"

  private static Map<String, Object> deepkeymap;

现在，我想将我的 deepkeymap 转换为像这样工作的嵌套映射：{firstkey={secondkey={thirdkey="Example value"}}}，我的 deepkeymap 实际上存储了 4 个具有 4 个值的键（数量键和值会改变）。我已经完成了这一点，但并不完全，因为它只转换了我的 deepkeymap 的最后一个键和值，事实上，我放的示例是我的嵌套映射的输出，这里是代码：

public void save() {
    try {
        Map<String, Object> datamap = new HashMap<String, Object>();
        for(String key : deepkeymap.keySet()) {
            Object value = deepkeymap.get(key);
            int end = key.length();
            for(int start; (start = key.lastIndexOf('.', end - 1)) != -1; end = start) {
                value = new HashMap<>(Collections.singletonMap(key.substring(start + 1, end), value));
            }
            datamap.putAll(new HashMap<>(Collections.singletonMap(key.substring(0, end), value)));
        }
        System.out.println("Datamap: "+datamap);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

如上所述，输出为：

Datamap: {firstkey={secondkey={thirdkey="Example value"}}}

但它应该有另外 3 个键，因为 deepkeymap 包含 4 个键和它们各自的 4 个值，我已经检查过它们存储在上面并且没有人有空值，对 keySet 循环打印键和值进行调试。

Answer 1

您可以使用下面的代码。工厂方法因输入错误而失败，而且DeepKeyMap只有toString。下面是一个 JUnit 测试，它只运行代码并且什么都不测试。如果您将来使用它，您可以将 DeepKeyMap 提取到一个单独的类中。

public class MapTest
{
    static class DeepKeyMap
    {
        Map<String, Object> map = new HashMap<>();

        public void put(
                String path,
                Object value
        )
        {
            String[] split = path.split("\\.");

            this.put(split, value);
        }

        public void put(
                String[] path,
                Object value
        )
        {
            Map<String, Object> deepestMap = createMapsToTheDeepestKey(path);
            String deepestKey = path[path.length - 1];

            deepestMap.put(deepestKey, value);
        }

        private Map<String, Object> createMapsToTheDeepestKey(String[] path)
        {
            Map<String, Object> deepestMap = map;

            for (int i = 0; i < path.length - 1; i++)
            {
                String key = path[i];
                deepestMap = getDeeperMap(deepestMap, key);
            }

            return deepestMap;
        }

        private Map<String, Object> getDeeperMap(
                Map<String, Object> deepestMap,
                String key
        )
        {
            if (!deepestMap.containsKey(key))
            {
                deepestMap.put(key, new HashMap<>());
            }

            return (Map<String, Object>) deepestMap.get(key);
        }

        @Override
        public String toString()
        {
            return map.toString();
        }

        public static DeepKeyMap from(Map<String, Object> original)
        {
            DeepKeyMap result = new DeepKeyMap();

            // the for loop can be minimized to
            // original.forEach(result::put);
            for (var entry : original.entrySet())
            {
                result.put(entry.getKey(), entry.getValue());
            }

            return result;
        }
    }

    @Test
    void test()
    {
        Map<String, Object> original = Map.of("flat", "First Level",
                "nested.value.one", "Second Level",
                "nested.value.two", "Third Level",
                "nested.different.value.one", "Fourth Level"
        );

        DeepKeyMap deepMap = DeepKeyMap.from(original);

        System.out.println(deepMap);
    }
}

编辑：我稍微重构了上面的代码。希望它更清楚它的作用。

Answer 2

我不会那样使用它，你可以在不同的级别上有相同的键，这不是 Map 的意图。

此外，您可以生成一个结构，其键类型为映射或字符串。这带来了各种不确定性。

您应该考虑使用其他数据结构或数据库。

您的意图是什么，也许我们可以为您提供帮助。