Java8: HashMap <X, Y> Hashmap <X, Z> mit Strom/Map-Reduce/Collector

Question

Ich weiß, wie man "transformieren", um eine einfache Java-List von Y ->Z, das heißt:

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

Nun möchte Ich mag an im Grunde das gleiche mit einer Karte, das heißt: ->Integer

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 begrenzt werden. Genau wie im oben genannten Beispiel möchte ich jede Methode (oder Konstruktor) aufrufen.

Answer 1

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 keine neuen Map.Entry s in einem map() Anruf erstellen, so dass die Arbeit in den collect() Aufruf gemischt wird.

Answer 2

Eine generische Lösung wie so

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)); 

Answer 3

Hier sind einige Variationen auf Sotirios Delimanolis' answer, das war ziemlich gut mit (+1) zu beginnen. Beachten Sie Folgendes:

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 notwendig, wenn zum Beispiel, können Sie die Ausgabe der Karte wollte einen Schlüssel haben, ist eine übergeordnete Klasse der Eingangskarte Schlüssel:

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 ist auch ein Beispiel für die Karte Werte, aber es ist wirklich gekünstelt , und ich gebe zu, dass die begrenzte Wildcard für Y nur in Rand Fällen hilft.)

Ein zweiter Punkt ist, dass statt den Strom über die Eingabe Map entrySet lief ich es über die keySet. Das macht den Code ein wenig sauberer, auf Kosten von Werten aus der Map statt aus dem Map-Eintrag. Übrigens hatte ich zunächst key -> key als erstes Argument zu toMap() und dies fehlgeschlagen mit einem Typ Inferenz Fehler aus irgendeinem Grund. Ändern Sie es zu (X key) -> key gearbeitet, wie auch Function.identity().

Noch eine andere Variante 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() statt Streams. Das ist noch einfacher, denke ich, weil es auf die Sammler verzichtet, die mit Karten etwas unbeholfen sind. Der Grund dafür ist, dass Map.forEach() den Schlüssel und den Wert als separate Parameter angibt, während der Stream nur einen Wert hat - und Sie müssen wählen, ob Sie den Schlüssel oder den Map-Eintrag als diesen Wert verwenden möchten. Auf der Minus-Seite mangelt es der reichen, stromreichen Güte der anderen Ansätze. :-)

Answer 4

Muss es absolut 100% funktional und flüssig sein?Wenn nicht, wie wäre es damit, die etwa so kurz wie es geht:

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

(if you can live with the shame and guilt of combining streams with side-effects)

Answer 5

Meine StreamEx Bibliothek, die Standard-Stream API verbessert liefert eine EntryStream Klasse, die für die Transformation von Karten besser passt:

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

Answer 6

Wenn Sie nicht 3rd-Party-Bibliotheken nichts dagegen, meine cyclops-react lib hat Erweiterungen für alle JDK Collection-Typen, einschließlich Map. Wir können die Map einfach mit dem Operator 'map' transformieren (standardmäßig wirkt die Karte auf die Werte in der Karte).

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

bimap kann verwendet werden, um die Schlüssel und Werte in der gleichen Zeit zu transformieren

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

Answer 7

Eine Alternative, die für das Lernen Zweck immer existiert, ist Ihren benutzerdefinierten Collector durch Collector.of zu bauen(), obwohl toMap() JDK-Kollektor hier ist prägnant (+1 here).

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;} 
       )); 

Answer 8

Guava die Funktion Maps.transformValues ist das, was Sie suchen, und es funktioniert gut mit Lambda-Ausdrücke:

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

Answer 9

Die deklarative und einfachere Lösung wäre:

yourMutableMap.replaceAll ((key , val) -> return_value_of_bi_your_function); Nr. Beachten Sie, dass Sie Ihren Kartenstatus ändern. Das ist vielleicht nicht das, was du willst.

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