Java8: HashMap <X, Y> para HashMap <X, Z> usando Stream / Map-Reduce / Collector

Eu sei como "transformar" um Java simples Listde Y-> Z, ou seja:

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

Agora eu gostaria de fazer basicamente o mesmo com um mapa, ou seja:

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

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

A solução não deve ser limitada a String-> Integer. Assim como no Listexemplo acima, eu gostaria de chamar qualquer método (ou construtor).

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

Não é tão bom quanto o código da lista. Você não pode construir novos Map.Entrys em uma map()chamada, para que o trabalho seja misturado à collect()chamada.

Aqui estão algumas variações da resposta de Sotirios Delimanolis , que foi muito boa para começar (+1). Considere o seguinte:

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

Alguns pontos aqui. Primeiro é o uso de curingas nos genéricos; isso torna a função um pouco mais flexível. Um curinga seria necessário se, por exemplo, você desejasse que o mapa de saída tivesse uma chave que seja uma superclasse da chave do mapa de entrada:

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

(Também há um exemplo para os valores do mapa, mas é realmente artificial, e admito que ter o curinga limitado para Y ajuda apenas em casos extremos.)

Um segundo ponto é que, em vez de executar o fluxo sobre o mapa de entrada entrySet, eu o executei no keySet. Isso torna o código um pouco mais limpo, eu acho, ao custo de ter que buscar valores fora do mapa, e não na entrada do mapa. Aliás, eu inicialmente tive key -> keycomo o primeiro argumento toMap()e isso falhou com um erro de inferência de tipo por algum motivo. Mudando para (X key) -> keyfuncionou, assim comoFunction.identity() .

Ainda outra variação é a seguinte:

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

Isso usa em Map.forEach()vez de fluxos. Isso é ainda mais simples, eu acho, porque dispensa os colecionadores, que são um pouco desajeitados para usar nos mapas. O motivo é que Map.forEach()fornece a chave e o valor como parâmetros separados, enquanto o fluxo possui apenas um valor - e você deve escolher se deseja usar a chave ou a entrada do mapa como esse valor. No lado negativo, falta a bondade rica e fluida das outras abordagens. :-)

Uma solução genérica como essa

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

Exemplo

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

A função do Guava Maps.transformValuesé o que você está procurando e funciona bem com expressões lambda:

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

É absolutamente necessário que seja 100% funcional e fluente? Caso contrário, que tal isso, que é o mais curto possível:

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

( se você pode viver com a vergonha e a culpa de combinar fluxos com efeitos colaterais )

Minha biblioteca StreamEx , que aprimora a API de fluxo padrão, fornece uma EntryStreamclasse que melhor se adapta à transformação de mapas:

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

Uma alternativa que sempre existe para fins de aprendizado é criar seu coletor personalizado por meio de Collector.of (), embora o coletor toMap () JDK aqui seja sucinto (+1 aqui ).

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 você não se importa em usar bibliotecas de terceiros, minha lib cyclops- react possui extensões para todos os tipos de coleções do JDK , incluindo o Map . Podemos apenas transformar o mapa diretamente usando o operador 'map' (por padrão, o mapa atua sobre os valores no mapa).

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

O bimap pode ser usado para transformar as chaves e os valores ao mesmo tempo

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

A solução declarativa e mais simples seria:

yourMutableMap.replaceAll ((key, val) -> return_value_of_bi_your_function); Nb. esteja ciente de que está modificando o estado do seu mapa. Portanto, isso pode não ser o que você deseja.

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