Effiziente Methode zum Iterieren und Kopieren der Werte von HashMap

Ich möchte konvertieren:

Map<String, Map<String, List<Map<String, String>>>> inputMap 

zu:

Map<String, Map<String, CustomObject>> customMap

inputMapwird in der Konfiguration bereitgestellt und ist bereit, aber ich muss customMapformatieren. CustomObject wird aus der List<Map<String, String>>Verwendung weniger Codezeilen in einer Funktion abgeleitet.

Ich habe versucht, die Eingabekarte auf normale Weise zu iterieren und Schlüsselwerte in customMap zu kopieren. Gibt es eine effiziente Möglichkeit, dies mit Java 8 oder einer anderen Verknüpfung zu tun?

Map<String, Map<String, List<Map<String, String>>>> configuredMap = new HashMap<>();
Map<String, Map<String, CustomObj>> finalMap = new HashMap<>();


for (Map.Entry<String, Map<String, List<Map<String, String>>>> attributeEntry : configuredMap.entrySet()) {
    Map<String, CustomObj> innerMap = new HashMap<>();
    for (Map.Entry<String, List<Map<String, String>>> valueEntry : attributeEntry.getValue().entrySet()) {
        innerMap.put(valueEntry.getKey(), getCustomeObj(valueEntry.getValue()));
    }
    finalMap.put(attributeEntry.getKey(), innerMap);
}

private CustomObj getCustomeObj(List<Map<String, String>> list) {
    return new CustomObj();
}

Eine Lösung besteht darin, das entrySetvon zu streamen inputMapund dann Collectors#toMapzweimal zu verwenden (einmal für das Äußere Mapund einmal für das Innere Map):

Map<String, Map<String, CustomObj>> customMap = inputMap.entrySet()
        .stream()
        .collect(Collectors.toMap(Function.identity(), entry -> {
            return entry.getValue()
                        .entrySet()
                        .stream()
                        .collect(Collectors.toMap(Function.identity(), 
                            entry -> getCustomeObj(entry.getValue())));
        }));

Sie könnten streamen, aber das wird nicht lesbar aussehen. Zumindest für mich. Wenn Sie also eine Methode haben:

static CustomObject fun(List<Map<String, String>> in) {
    return .... // whatever processing you have here
}

Sie könnten die java-8Syntax weiterhin verwenden , jedoch in einer anderen Form:

    Map<String, Map<String, CustomObject>> customMap = new HashMap<>();

    inputMap.forEach((key, value) -> {

        value.forEach((innerKey, listOfMaps) -> {

            Map<String, CustomObject> innerMap = new HashMap<>();
            innerMap.put(innerKey, fun(listOfMaps));
            customMap.put(key, innerMap);

        });
    });

Wenn Sie die innere Karte erstellen können immutable, können Sie diese noch kürzer machen:

inputMap.forEach((key, value) -> {
      value.forEach((innerKey, listOfMaps) -> {
          customMap.put(key, Collections.singletonMap(innerKey, fun(listOfMaps)));
      });
});

IMHO Streaming ist keine so schlechte Idee. Es gibt keine schlechten Werkzeuge. Es hängt davon ab, wie Sie sie verwenden.

In diesem speziellen Fall würde ich das sich wiederholende Muster in eine Dienstprogrammmethode extrahieren:

public static <K, V1, V2> Map<K, V2> transformValues(Map<K, V1> map, Function<V1, V2> transformer) {
    return map.entrySet()
              .stream()
              .collect(toMap(Entry::getKey, e -> transformer.apply(e.getValue())));
}

Die obige Methode kann mit jedem Ansatz implementiert werden, obwohl ich denke, dass sie Stream APIhier ziemlich gut passt.

Sobald Sie die Dienstprogrammmethode definiert haben, kann sie wie folgt verwendet werden:

Map<String, Map<String, CustomObj>> customMap = 
    transformValues(inputMap, attr -> transformValues(attr, this::getCustomObj));

Die eigentliche Transformation ist effektiv ein Liner. So mit der richtigen JavaDocfür transformValuesMethode ist das Ergebnis Code ziemlich lesbar und wartbar.

Wie wäre es mit Collectors.toMapden Einträgen sowohl auf äußerer als auch auf innerer Ebene wie:

Map<String, Map<String, CustomObj>> finalMap = configuredMap.entrySet()
        .stream()
        .collect(Collectors.toMap(Map.Entry::getKey,
                attributeEntry -> attributeEntry.getValue().entrySet()
                        .stream()
                        .collect(Collectors.toMap(Map.Entry::getKey,
                                valueEntry -> getCustomeObj(valueEntry.getValue())))));