No Java 8, como transformar um mapa <K, V> em outro mapa <K, V> usando um lambda?

Acabei de começar a olhar para o Java 8 e experimentar lambdas. Pensei em tentar reescrever uma coisa muito simples que escrevi recentemente. Preciso transformar um mapa de seqüência de caracteres em coluna em outro mapa de seqüência de caracteres em coluna onde a coluna no novo mapa é uma cópia defensiva da coluna no primeiro mapa. A coluna possui um construtor de cópias. O mais próximo que eu tenho até agora é:

    Map<String, Column> newColumnMap= new HashMap<>();
    originalColumnMap.entrySet().stream().forEach(x -> newColumnMap.put(x.getKey(), new Column(x.getValue())));

mas tenho certeza de que deve haver uma maneira melhor de fazer isso e ficaria grato por alguns conselhos.

Você pode usar um coletor :

import java.util.*;
import java.util.stream.Collectors;

public class Defensive {

  public static void main(String[] args) {
    Map<String, Column> original = new HashMap<>();
    original.put("foo", new Column());
    original.put("bar", new Column());

    Map<String, Column> copy = original.entrySet()
        .stream()
        .collect(Collectors.toMap(Map.Entry::getKey,
                                  e -> new Column(e.getValue())));

    System.out.println(original);
    System.out.println(copy);
  }

  static class Column {
    public Column() {}
    public Column(Column c) {}
  }
}

Map<String, Integer> map = new HashMap<>();
map.put("test1", 1);
map.put("test2", 2);

Map<String, Integer> map2 = new HashMap<>();
map.forEach(map2::put);

System.out.println("map: " + map);
System.out.println("map2: " + map2);
// Output:
// map:  {test2=2, test1=1}
// map2: {test2=2, test1=1}

Você pode usar o forEachmétodo para fazer o que quiser.

O que você está fazendo lá é:

map.forEach(new BiConsumer<String, Integer>() {
    @Override
    public void accept(String s, Integer integer) {
        map2.put(s, integer);     
    }
});

Que podemos simplificar em um lambda:

map.forEach((s, integer) ->  map2.put(s, integer));

E, como estamos chamando um método existente, podemos usar uma referência de método , o que nos fornece:

map.forEach(map2::put);

O caminho sem reinserir todas as entradas no novo mapa deve ser o mais rápido possível, porque também HashMap.clonerealiza rehash internamente.

Map<String, Column> newColumnMap = originalColumnMap.clone();
newColumnMap.replaceAll((s, c) -> new Column(c));

Mantenha-o simples e use o Java 8: -

 Map<String, AccountGroupMappingModel> mapAccountGroup=CustomerDAO.getAccountGroupMapping();
 Map<String, AccountGroupMappingModel> mapH2ToBydAccountGroups = 
              mapAccountGroup.entrySet().stream()
                         .collect(Collectors.toMap(e->e.getValue().getH2AccountGroup(),
                                                   e ->e.getValue())
                                  );

Se você usar o Guava (mínimo da v11) em seu projeto, poderá usar o Maps :: transformValues .

Map<String, Column> newColumnMap = Maps.transformValues(
  originalColumnMap,
  Column::new // equivalent to: x -> new Column(x) 
)

Nota: Os valores deste mapa são avaliados preguiçosamente. Se a transformação for cara, você pode copiar o resultado para um novo mapa, como sugerido nos documentos do Guava.

To avoid lazy evaluation when the returned map doesn't need to be a view, copy the returned map into a new map of your choosing.

Aqui está outra maneira que fornece acesso à chave e ao valor ao mesmo tempo, caso você precise fazer algum tipo de transformação.

Map<String, Integer> pointsByName = new HashMap<>();
Map<String, Integer> maxPointsByName = new HashMap<>();

Map<String, Double> gradesByName = pointsByName.entrySet().stream()
        .map(entry -> new AbstractMap.SimpleImmutableEntry<>(
                entry.getKey(), ((double) entry.getValue() /
                        maxPointsByName.get(entry.getKey())) * 100d))
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

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 . Você pode usar diretamente os métodos de mapa ou bimap para transformar seu mapa. Um MapX pode ser construído a partir de um mapa existente, por exemplo.

  MapX<String, Column> y = MapX.fromMap(orgColumnMap)
                               .map(c->new Column(c.getValue());

Se você também deseja alterar a chave, pode escrever

  MapX<String, Column> y = MapX.fromMap(orgColumnMap)
                               .bimap(this::newKey,c->new Column(c.getValue());

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

À medida que o MapX estende o mapa, o mapa gerado também pode ser definido como

  Map<String, Column> y