Java8: HashMap <X, Y> zu HashMap <X, Z> mit Stream / Map-Reduce / Collector

Ich weiß, wie man ein einfaches Java Listvon Y-> "transformiert" Z, dh:

List<String> x;
List<Integer> y = x.stream()
        .map(s -> Integer.parseInt(s))
        .collect(Collectors.toList());

Jetzt möchte ich im Grunde dasselbe mit einer Karte machen, dh:

INPUT:
{
  "key1" -> "41",    // "41" and "42"
  "key2" -> "42      // are Strings
}

OUTPUT:
{
  "key1" -> 41,      // 41 and 42
  "key2" -> 42       // are Integers
}

Die Lösung sollte nicht auf String-> beschränkt sein Integer. Genau wie im Listobigen Beispiel möchte ich eine beliebige Methode (oder einen Konstruktor) aufrufen.

Map<String, String> x;
Map<String, Integer> y =
    x.entrySet().stream()
        .collect(Collectors.toMap(
            e -> e.getKey(),
            e -> Integer.parseInt(e.getValue())
        ));

Es ist nicht ganz so schön wie der Listencode. Sie können Map.Entryin einem map()Aufruf keine neuen s erstellen, sodass die Arbeit in den collect()Aufruf eingemischt wird .

Hier sind einige Variationen der Antwort von Sotirios Delimanolis , die anfangs ziemlich gut war (+1). Folgendes berücksichtigen:

static <X, Y, Z> Map<X, Z> transform(Map<? extends X, ? extends Y> input,
                                     Function<Y, Z> function) {
    return input.keySet().stream()
        .collect(Collectors.toMap(Function.identity(),
                                  key -> function.apply(input.get(key))));
}

Ein paar Punkte hier. Erstens ist die Verwendung von Platzhaltern in den Generika; Dies macht die Funktion etwas flexibler. Ein Platzhalter wäre erforderlich, wenn Sie beispielsweise möchten, dass die Ausgabekarte einen Schlüssel enthält, der eine Oberklasse des Schlüssels der Eingabekarte ist:

Map<String, String> input = new HashMap<String, String>();
input.put("string1", "42");
input.put("string2", "41");
Map<CharSequence, Integer> output = transform(input, Integer::parseInt);

(Es gibt auch ein Beispiel für die Werte der Karte, aber es ist wirklich erfunden, und ich gebe zu, dass der begrenzte Platzhalter für Y nur in Randfällen hilfreich ist.)

Ein zweiter Punkt ist, dass entrySetich den Stream nicht über die Eingabe-Map laufen ließ , sondern über die keySet. Dies macht den Code meiner Meinung nach ein wenig sauberer, da Werte aus der Karte anstatt aus dem Karteneintrag abgerufen werden müssen. Übrigens hatte ich zunächst key -> keyals erstes Argument dazu toMap()und dies schlug aus irgendeinem Grund mit einem Typinferenzfehler fehl. Es (X key) -> keyfunktionierte genauso wie es funktionierte Function.identity().

Eine weitere Variation ist wie folgt:

static <X, Y, Z> Map<X, Z> transform1(Map<? extends X, ? extends Y> input,
                                      Function<Y, Z> function) {
    Map<X, Z> result = new HashMap<>();
    input.forEach((k, v) -> result.put(k, function.apply(v)));
    return result;
}

Dies verwendet Map.forEach()anstelle von Streams. Das ist noch einfacher, denke ich, weil es auf die Sammler verzichtet, deren Verwendung mit Karten etwas umständlich ist. Der Grund dafür ist, dass Map.forEach()der Schlüssel und der Wert als separate Parameter angegeben werden, während der Stream nur einen Wert hat - und Sie müssen auswählen, ob Sie den Schlüssel oder den Karteneintrag als diesen Wert verwenden möchten. Auf der negativen Seite fehlt dies die reiche, strömende Güte der anderen Ansätze. :-)

Eine generische Lösung wie diese

public static <X, Y, Z> Map<X, Z> transform(Map<X, Y> input,
        Function<Y, Z> function) {
    return input
            .entrySet()
            .stream()
            .collect(
                    Collectors.toMap((entry) -> entry.getKey(),
                            (entry) -> function.apply(entry.getValue())));
}

Beispiel

Map<String, String> input = new HashMap<String, String>();
input.put("string1", "42");
input.put("string2", "41");
Map<String, Integer> output = transform(input,
            (val) -> Integer.parseInt(val));

Guavas Funktion Maps.transformValuesist genau das, wonach Sie suchen, und sie funktioniert gut mit Lambda-Ausdrücken:

Maps.transformValues(originalMap, val -> ...)

Muss es unbedingt 100% funktional und fließend sein? Wenn nicht, wie wäre es damit, das so kurz wie möglich ist:

Map<String, Integer> output = new HashMap<>();
input.forEach((k, v) -> output.put(k, Integer.valueOf(v));

( wenn Sie mit der Schande und Schuld leben können, Streams mit Nebenwirkungen zu kombinieren )

Meine StreamEx- Bibliothek, die die Standard-Stream-API erweitert, bietet eine EntryStreamKlasse, die sich besser zum Transformieren von Karten eignet :

Map<String, Integer> output = EntryStream.of(input).mapValues(Integer::valueOf).toMap();

Eine Alternative, die es zu Lernzwecken immer gibt, besteht darin, Ihren benutzerdefinierten Kollektor über Collector.of () zu erstellen, obwohl der JDK-Kollektor toMap () hier kurz und bündig ist (+1 hier ).

Map<String,Integer> newMap = givenMap.
                entrySet().
                stream().collect(Collector.of
               ( ()-> new HashMap<String,Integer>(),
                       (mutableMap,entryItem)-> mutableMap.put(entryItem.getKey(),Integer.parseInt(entryItem.getValue())),
                       (map1,map2)->{ map1.putAll(map2); return map1;}
               ));

Wenn es Ihnen nichts ausmacht, Bibliotheken von Drittanbietern zu verwenden, enthält meine Cyclops-React- Bibliothek Erweiterungen für alle JDK-Sammlungstypen , einschließlich Map . Wir können die Karte einfach direkt mit dem Operator 'map' transformieren (standardmäßig wirkt sich die Map auf die Werte in der Map aus).

   MapX<String,Integer> y = MapX.fromMap(HashMaps.of("hello","1"))
                                .map(Integer::parseInt);

Mit bimap können die Schlüssel und Werte gleichzeitig transformiert werden

  MapX<String,Integer> y = MapX.fromMap(HashMaps.of("hello","1"))
                               .bimap(this::newKey,Integer::parseInt);

Die deklarative und einfachere Lösung wäre:

yourMutableMap.replaceAll ((Schlüssel, Wert) -> return_value_of_bi_your_function); Nb. Beachten Sie, dass Sie Ihren Kartenstatus ändern. Das ist vielleicht nicht das, was Sie wollen.

Prost an: http://www.deadcoderising.com/2017-02-14-java-8-declarative-ways-of-modifying-a-map-using-compute-merge-and-replace/