java - simplificar - metodo tabular de karnaugh

En Java 8, ¿cómo transformo un Mapa<K, V> en otro Mapa<K, V> usando un lambda?

Question

Acabo de empezar a buscar en Java 8 y probar lambdas. Pensé que intentaría reescribir una cosa muy simple que escribí recientemente. Necesito convertir un Mapa de cadena a columna en otro Mapa de cadena a columna donde la columna en el nuevo Mapa es una copia defensiva de la columna en el primer Mapa. Column tiene un constructor de copia. Lo más cercano que tengo hasta ahora es:

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

pero estoy seguro de que debe haber una forma más agradable de hacerlo y le agradecería algún consejo.

Answer 1

Aquí hay otra forma que le da acceso a la clave y al valor al mismo tiempo, en caso de que tenga que hacer algún tipo de transformación.

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

Answer 2

Mantenlo simple y 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())
                                  );

Answer 3

Puedes usar un Collector :

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

Answer 4

Si no te importa utilizar bibliotecas de terceros, cyclops-react lib tiene extensiones para todos los tipos de colecciones JDK , incluido Map . Puede usar directamente los métodos de mapa o bimap para transformar su Mapa. Un MapX se puede construir a partir de un mapa existente, por ejemplo.

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

Si también deseas cambiar la clave, puedes escribir

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

bimap se puede usar para transformar las claves y los valores al mismo tiempo.

A medida que MapX extiende Map, el mapa generado también se puede definir como

  Map<String, Column> y

Answer 5

El camino sin volver a insertar todas las entradas en el nuevo mapa debería ser el más rápido que no lo hará porque HashMap.clone realiza internamente HashMap.clone .

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

Answer 6

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}

Puede usar el método forEach para hacer lo que desee.

Lo que estás haciendo allí es:

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

Que podemos simplificar en una lambda:

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

Y debido a que estamos llamando a un método existente, podemos usar una referencia de método , que nos da:

map.forEach(map2::put);