Java 压平字典

给定一个dictionary dict，编写一个函数flattedictionary，返回该dictionary的展平版本

input:  dict = {
        "Key1" : "1",
        "Key2" : {
            "a" : "2",
            "b" : "3",
            "c" : {
                "d" : "3",
                "e" : {
                    "" : "1"
                }
            }
        }
    }

output: {
        "Key1" : "1",
        "Key2.a" : "2",
        "Key2.b" : "3",
        "Key2.c.d" : "3",
        "Key2.c.e" : "1"
    }

类解决方案{
静态HashMap字典（HashMap dict）{
HashMapresult=新的HashMap（）；
展平嵌套（“”，dict，result）；
返回结果；
}
私有静态空洞展开嵌套（字符串父项、映射dict、映射结果）{
for（Map.Entry:dict.entrySet（））{
if（entry.getValue（）instanceof String）{
putEntryInResult（父项、结果、条目）；
}否则{
FlattNextLevel（父级、结果、条目）；
}
}
}
私有静态void flattenxtlevel（字符串父级、映射结果、，
地图（输入）{
if（parent.isEmpty（））{
展开嵌套（entry.getKey（），（Map）entry.getValue（），result）；
}否则{
字符串key=entry.getKey（）.isEmpty（）？父项：parent+““+entry.getKey（）；
展开嵌套（键，（映射）条目.getValue（），结果）；
}
}
私有静态void putentrynresult（字符串父级、映射结果、，
地图（输入）{
if（parent.isEmpty（））{
result.put（entry.getKey（），entry.getValue（）.toString（））；
}否则{
字符串key=entry.getKey（）.isEmpty（）？父项：parent+““+entry.getKey（）；
result.put（key，entry.getValue（）.toString（））；
}
}
公共静态void main（字符串[]args）{
HashMap dict=新HashMap（）；
dict.put（“键1”、“1”）；
HashMap c=新的HashMap（）；
c、 认沽权（“d”、“3”）；认沽权（“e”、“1”）；
HashMap key2=新的HashMap（）；
键2.放置（“a”、“2”）；
键2.put（“b”，“3”）；
键2.put（“c”，c）；
dict.put（“键2”，键2）；
}
}

class Solution {

 static HashMap<String, String> flattenDictionary(HashMap<String, Object> dict) {
  HashMap<String, String>result = new HashMap<String, String>();
  flattenNesting("", dict, result);

  return result;

 }

    private static void flattenNesting(String parent, Map<String, Object> dict, Map<String, 
 String> result) {
    for (Map.Entry<String, Object> entry : dict.entrySet()) {
        if (entry.getValue() instanceof String) {
            putEntryInResult(parent, result, entry);
        } else {
            flattenNextLevel(parent, result, entry);
        }
    }
}


   private static  void flattenNextLevel(String parent, Map<String, String> result, 
   Map.Entry<String, Object> entry) {
    if (parent.isEmpty()) {
        flattenNesting(entry.getKey(), (Map<String, Object>) entry.getValue(), result);
    } else {
        String key = entry.getKey().isEmpty() ? parent : parent + "." + entry.getKey();
        flattenNesting(key, (Map<String, Object>) entry.getValue(), result);
    }
}


  private static void putEntryInResult(String parent, Map<String, String> result, 
   Map.Entry<String, Object> entry) {
    if (parent.isEmpty()) {
        result.put(entry.getKey(), entry.getValue().toString());
    } else {
        String key = entry.getKey().isEmpty() ? parent : parent + "." + entry.getKey();
        result.put(key, entry.getValue().toString());
    }
}


 public static void main(String[] args) {
    HashMap<String, Object> dict = new HashMap<String, Object>();   
    dict.put("key1", "1");
    HashMap<String, Object> c = new HashMap<String, Object>();
    c.put("d", "3"); c.put("e", "1");
    HashMap<String, Object> key2 = new HashMap<String, Object>();
    key2.put("a", "2"); 
    key2.put("b", "3"); 
    key2.put("c", c);
    dict.put("key2", key2);
  }

}