Java8: HashMap <X, Y> per hashmap <X, Z> utilizzando Ruscello/Map-Reduce/Collector

Question

so come "trasformare" un semplice Java List da Y ->Z, vale a dire:

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

Ora mi piacerebbe fare fondamentalmente la stessa cosa 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 deve essere limitata a String ->Integer. Proprio come nell'esempio List sopra, mi piacerebbe chiamare qualsiasi metodo (o costruttore).

Answer 1

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

Non è bello come il codice di elenco. Non è possibile creare nuovi Map.Entry s in una chiamata map() in modo che il lavoro venga mixato nella chiamata collect().

Answer 2

Una soluzione generica questo modo

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

Answer 3

Ecco alcune varianti Sotirios Delimanolis' answer, che era abbastanza buono 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 jolly sarebbe necessario se, ad esempio, si voleva la mappa di output di avere una chiave che è una superclasse di 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 artificiosa e ammetto che avere il carattere jolly limitato per Y aiuta solo nei casi limite.)

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

Ancora un'altra variante è 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é dispensa con i collezionisti, che sono piuttosto 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 utilizzare la chiave o la voce della mappa come tale valore. Sul lato negativo, questo manca della ricca, fluida bontà degli altri approcci. :-)

Answer 4

Dev'essere assolutamente funzionale e scorrevole al 100%?Se no, come su questo, che è di circa il più breve, come si arriva:

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

mio StreamEx biblioteca che migliora flusso di API standard fornisce una classe EntryStream che si adatta meglio per le mappe di trasformazione:

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

Answer 6

Se non ti dispiace utilizzando le librerie 3rd party, il mio cyclops-react lib ha estensioni per tutti i tipi, tra JDK CollectionMap. Possiamo semplicemente trasformare la mappa direttamente usando l'operatore 'mappa' (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 utilizzato per trasformare le chiavi ei valori allo stesso tempo

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

Answer 7

Un'alternativa che esiste da sempre per l'apprendimento scopo è quello di costruire la vostra collezione personalizzata attraverso Collector.of() anche se toMap() Il raccoglitore JDK qui è succinto (+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

funzione di Guava Maps.transformValues è quello che stai cercando, e funziona bene con le espressioni lambda:

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

Answer 9

La soluzione dichiarativa e più semplice sarebbe:

yourMutableMap.replaceAll ((chiave , val) -> return_value_of_bi_your_function); Nb. sii consapevole della modifica dello stato della tua 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/