In Java 8 come posso trasformare una mappa <K, V> in un'altra mappa <K, V> usando una lambda?

Ho appena iniziato a guardare Java 8 e per provare lambdas ho pensato di provare a riscrivere una cosa molto semplice che ho scritto di recente. Devo trasformare una Mappa di stringa in colonna in un'altra Mappa di stringa in colonna in cui la colonna nella nuova mappa è una copia difensiva della colonna nella prima mappa. La colonna ha un costruttore di copie. Il più vicino che ho finora è:

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

ma sono sicuro che ci deve essere un modo migliore per farlo e sarei grato per qualche consiglio.

Puoi usare un Collezionista :

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}

Puoi usare il forEachmetodo per fare quello che vuoi.

Quello che stai facendo lì è:

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

Che possiamo semplificare in una lambda:

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

E poiché stiamo solo chiamando un metodo esistente, possiamo usare un riferimento al metodo , che ci dà:

map.forEach(map2::put);

Il modo in cui non è necessario reinserire tutte le voci nella nuova mappa dovrebbe essere il più veloce perché non HashMap.cloneesegue internamente anche la rehash.

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

Keep it Simple e usa 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 usi Guava (minimo v11) nel tuo progetto puoi usare Maps :: transformValues .

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

Nota: i valori di questa mappa vengono valutati pigramente. Se la trasformazione è costosa, puoi copiare il risultato in una nuova mappa come suggerito nei documenti di 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.

Ecco un altro modo che ti dà accesso alla chiave e al valore allo stesso tempo, nel caso in cui tu debba fare un qualche tipo di trasformazione.

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 non ti dispiace usare librerie di terze parti, la mia libreria cyclops- reazioni ha estensioni per tutti i tipi di raccolte JDK , inclusa Map . Puoi utilizzare direttamente i metodi mappa o bimap per trasformare la tua mappa. Una MapX può essere costruita da una Mappa esistente ad es.

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

Se desideri anche cambiare la chiave, puoi scrivere

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

bimap può essere usato per trasformare chiavi e valori contemporaneamente.

Man mano che MapX estende la mappa, la mappa generata può anche essere definita come

  Map<String, Column> y