Java8: HashMap <X, Y> su HashMap <X, Z> utilizzando Stream / Map-Reduce / Collector

So come "trasformare" un semplice Java Listda Y-> Z, ovvero:

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

Ora vorrei fare sostanzialmente lo stesso con una mappa, vale a dire:

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

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

La soluzione non dovrebbe essere limitata a String-> Integer. Proprio come Listnell'esempio sopra, vorrei chiamare qualsiasi metodo (o costruttore).

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

Non è così bello come il codice dell'elenco. Non è possibile costruire nuovi messaggi Map.Entryin una map()chiamata, quindi il lavoro viene mischiato nella collect()chiamata.

Ecco alcune variazioni sulla risposta di Sotirios Delimanolis , che era abbastanza buona per cominciare (+1). Considera quanto segue:

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

Un paio di punti qui. Il primo è l'uso di caratteri jolly nei generici; questo rende la funzione un po 'più flessibile. Un carattere jolly sarebbe necessario se, ad esempio, si desidera che la mappa di output abbia una chiave che è una superclasse della chiave della mappa di input:

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

(C'è anche un esempio per i valori della mappa, ma è davvero inventato, e ammetto che avere il jolly limitato per Y aiuta solo nei casi limite.)

Un secondo punto è che invece di eseguire lo stream sulla mappa di input entrySet, l'ho eseguito su keySet. Questo rende il codice un po 'più pulito, credo, a costo di dover recuperare valori dalla mappa anziché dalla voce della mappa. Per inciso, inizialmente ho avuto key -> keycome primo argomento toMap()e questo non è riuscito con un errore di inferenza del tipo per qualche motivo. Cambiandolo in (X key) -> keyfunzionato, come ha fatto Function.identity().

Ancora un'altra variazione è la seguente:

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

Questo utilizza Map.forEach()invece di flussi. Questo è ancora più semplice, penso, perché fa a meno dei collezionisti, che sono un po 'goffi da usare con le mappe. Il motivo è che Map.forEach()fornisce la chiave e il valore come parametri separati, mentre lo stream ha un solo valore - e devi scegliere se usare la chiave o la voce della mappa come quel valore. Sul lato negativo, questo manca della bontà ricca e fluida degli altri approcci. :-)

Una soluzione generica come questa

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

Esempio

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

La funzione di Guava Maps.transformValuesè ciò che stai cercando e funziona bene con le espressioni lambda:

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

Deve essere assolutamente funzionale e scorrevole al 100%? In caso contrario, che ne dici di questo, che è circa il più corto possibile:

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

( se riesci a convivere con la vergogna e il senso di colpa di combinare flussi con effetti collaterali )

La mia libreria StreamEx che migliora l'API stream standard fornisce una EntryStreamclasse che si adatta meglio alla trasformazione delle mappe:

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

Un'alternativa che esiste sempre a scopo di apprendimento è quella di costruire il tuo raccoglitore personalizzato tramite Collector.of () sebbene toMap () il raccoglitore JDK qui sia succinto (+1 qui ).

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

Se non ti dispiace usare librerie di terze parti, la mia libreria cyclops- reazioni ha estensioni per tutti i tipi di raccolte JDK , inclusa Map . Possiamo semplicemente trasformare la mappa direttamente usando l'operatore 'map' (per impostazione predefinita la mappa agisce sui valori nella mappa).

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

bimap può essere usato per trasformare chiavi e valori contemporaneamente

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

La soluzione dichiarativa e più semplice sarebbe:

yourMutableMap.replaceAll ((key, val) -> return_value_of_bi_your_function); Nb. attenzione a modificare lo stato della mappa. Quindi questo potrebbe non essere quello che vuoi.

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