Java8: HashMap <X, Y> à HashMap <X, Z> à l'aide de Stream / Map-Reduce / Collector

Je sais comment "transformer" un simple Java à Listpartir de Y-> Z, c'est-à-dire:

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

Maintenant, je voudrais faire la même chose avec une carte, c'est-à-dire:

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

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

La solution ne doit pas se limiter à String-> Integer. Tout comme dans l' Listexemple ci-dessus, je voudrais appeler n'importe quelle méthode (ou constructeur).

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

Ce n'est pas aussi agréable que le code de liste. Vous ne pouvez pas construire de nouveaux Map.Entrys dans un map()appel, donc le travail est mélangé à l' collect()appel.

Voici quelques variantes de la réponse de Sotirios Delimanolis , qui était plutôt bonne au départ (+1). Considérer ce qui suit:

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

Quelques points ici. Le premier est l'utilisation de caractères génériques dans les génériques; cela rend la fonction un peu plus flexible. Un caractère générique serait nécessaire si, par exemple, vous vouliez que la carte de sortie ait une clé qui est une superclasse de la clé de la carte d'entrée:

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

(Il existe également un exemple pour les valeurs de la carte, mais il est vraiment artificiel, et j'avoue que le caractère générique borné pour Y n'aide que dans les cas limites.)

Un deuxième point est qu'au lieu d'exécuter le flux sur la carte d'entrée entrySet, je l'ai exécuté sur keySet. Cela rend le code un peu plus propre, je pense, au prix d'avoir à extraire des valeurs de la carte plutôt que de l'entrée de la carte. Par ailleurs, j'ai d'abord eu key -> keycomme premier argument toMap()et cela a échoué avec une erreur d'inférence de type pour une raison quelconque. Le changer en (X key) -> keyfonction, comme l'a fait Function.identity().

Une autre variante encore est la suivante:

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

Cela utilise à la Map.forEach()place des flux. C'est encore plus simple, je pense, car cela évite les collecteurs, qui sont un peu maladroits à utiliser avec les cartes. La raison en est que Map.forEach()donne la clé et la valeur en tant que paramètres séparés, alors que le flux n'a qu'une seule valeur - et vous devez choisir d'utiliser la clé ou l'entrée de carte comme valeur. Du côté négatif, cela n'a pas la richesse et la bonté des autres approches. :-)

Une solution générique comme ça

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

Exemple

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 fonction de la goyave Maps.transformValuesest ce que vous recherchez, et elle fonctionne bien avec les expressions lambda:

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

Doit-elle absolument être 100% fonctionnelle et fluide? Sinon, que diriez-vous de cela, qui est à peu près aussi court que possible:

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

( si vous pouvez vivre avec la honte et la culpabilité de combiner des flux avec des effets secondaires )

Ma bibliothèque StreamEx qui améliore l'API de flux standard fournit une EntryStreamclasse qui convient mieux à la transformation de cartes:

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

Une alternative qui existe toujours à des fins d'apprentissage est de construire votre collecteur personnalisé via Collector.of () bien que le collecteur JDK toMap () ici soit succinct (+1 ici ).

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

Si cela ne vous dérange pas d'utiliser des bibliothèques tierces, ma bibliothèque cyclops- react a des extensions pour tous les types de collections JDK , y compris Map . Nous pouvons simplement transformer la carte directement en utilisant l'opérateur 'map' (par défaut, map agit sur les valeurs de la carte).

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

bimap peut être utilisé pour transformer les clés et les valeurs en même temps

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

La solution déclarative et plus simple serait:

yourMutableMap.replaceAll ((key, val) -> return_value_of_bi_your_function); Nb. sachez que vous modifiez l'état de votre carte. Donc, ce n'est peut-être pas ce que vous voulez.

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