Java8: HashMap & lt; X, Y & gt; HashMap & lt; X, Z & gt; Verwenden von Stream / Map-Reduce / Collector

Ich wissen, wie Sie "transform" - eine einfache Java - List aus Y -> Zd.h.:

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

Nun möchte ich tun im Grunde das gleiche mit einer Karte, also:

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 begrenzt werden, um String -> Integer. Genau wie in der List Beispiel oben, würde ich mag, rufen Sie eine Methode (oder Konstruktor).

InformationsquelleAutor der Frage Benjamin M | 2014-09-18

  1. 231
    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 die Liste code. Sie können nicht konstruieren neue Map.Entrys in einem map() nennen, so ist die Arbeit gemischt in die collect() nennen.

    InformationsquelleAutor der Antwort John Kugelman

  2. 25

    Hier sind einige Variationen auf Sotirios Delimanolis' Antwortdie war ziemlich gut zu beginnen mit (+1). Betrachten Sie das folgende:

    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. Die erste ist die Verwendung von wildcards in der Generika; das macht die Funktion etwas flexibler. Eine wildcard wäre notwendig, wenn, zum Beispiel, Sie wollten den Ausgang der Karte zu haben, ein Schlüssel, der eine Superklasse von der input-map-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);

    (Dort ist auch ein Beispiel für die Karte die Werte, aber es ist wirklich zu konstruiert, und ich gebe zu, dass die bounded wildcard für die Y-hilft nur in Rand-Fällen.)

    Zweite Punkt ist, dass, anstatt den Strom über die input map ' s entrySet ich rannte ihn über den keySet. Das macht den code ein wenig sauberer, ich denke, bei den Kosten, die zum abrufen der Werte aus der Karte statt der von den map-Eintrag. Übrigens hatte ich anfangs key -> key als erstes argument toMap() und dies nicht mit einer Typ-Inferenz-Fehler aus irgendeinem Grund. Ändern Sie es zu (X key) -> key gearbeitet, wie Function.identity().

    Immer noch eine andere Variante 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;
}

    Diese verwendet Map.forEach() statt streams. Dieser ist sogar noch einfacher, denke ich, weil es keine Sammler, die etwas schwerfällig zu bedienen mit Karten. Der Grund dafür ist, dass Map.forEach() gibt den Schlüssel und den Wert als einzelne Parameter, in der Erwägung, dass der stream hat nur einen Wert -- und Sie haben die Wahl, ob Sie die-Taste oder die map-Eintrag als Wert. Auf der minus-Seite, diese fehlt den reichen, streamy Güte der anderen Ansätze. 🙂

    InformationsquelleAutor der Antwort Stuart Marks

  3. 11

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

    InformationsquelleAutor der Antwort Sotirios Delimanolis

  4. 6

    Tut es absolut und zu 100% funktionsfähig und fließend? Wenn nicht, wie wäre es damit, das ist etwa so kurz wie es geht:

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

    (wenn Sie Leben können mit der Scham und Schuld, der Kombination von strömen mit Nebenwirkungen)

    InformationsquelleAutor der Antwort Lukas Eder

  5. 5

    Meine StreamEx Bibliothek, die verbessert die standard-Streams-API bietet eine EntryStream Klasse, die passt besser für die Transformation von Karten:

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

    InformationsquelleAutor der Antwort Tagir Valeev

  6. 5

    Guave Funktion Karten.transformValues ist, was Sie suchen, und es funktioniert gut mit lambda-Ausdrücken:

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

    InformationsquelleAutor der Antwort Alex Krauss

  7. 3

    Eine alternative, die immer vorhanden ist, für das lernen Zweck ist es, erstellen Sie Ihre eigene Sammler über Sammler.() obwohl toMap() der JDK-Sammler hier wird lapidar (+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;}
               ));

    InformationsquelleAutor der Antwort Ira

  8. 2

    Wenn Euch das nichts ausmacht mit 3rd-party-Bibliotheken, meine cyclops-reagieren lib hat Erweiterungen für alle JDK-Collection - Typen, einschließlich Anzeigen. Wir können nur verwandeln die Karte direkt über die 'map' - operator (standardmäßig wird die Karte wirkt auf die Werte in der map).

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

    bimap kann verwendet werden, um umzuwandeln die Schlüssel und Werte gleichzeitig

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

    InformationsquelleAutor der Antwort John McClean

  9. 0

    Deklarativen und einfachere Lösung wäre :

    yourMutableMap.replaceAll((key, val) -> return_value_of_bi_your_function);
    Nb. sich bewusst sein, Ihre änderung Ihrer Karte Stand. Also das kann nicht sein, was Sie wollen.

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

    InformationsquelleAutor der Antwort Breton F.

Schreibe einen Kommentar