Cómo inicializar correctamente el Mapa de Mapa de Mapa?

Question

Puede ser una mala práctica, pero no he podido encontrar una solución mejor para mi problema. Así que tengo este mapa

// Map<state, Map<transition, Map<property, value>>> 
private Map<String, Map<String, Map<String, String>>> properties; 

y quiero inicializarlo por lo que no entiendo NullPointerException con este

properties.get("a").get("b").get("c"); 

Probé este, pero que no funcionó (obviamente)

properties = new HashMap<String, Map<String, Map<String,String>>>(); 

Otras cosas que probé no se compilaron.

Además, si tiene alguna idea sobre cómo evitar estos mapas anidados, se lo agradecería.

Answer 1

Necesita colocar mapas en sus mapas en su mapa. Literalmente:

properties = new HashMap<String, Map<String, Map<String,String>>>(); 
properties.put("a", new HashMap<String, Map<String,String>>()); 
properites.get("a").put("b", new HashMap<String,String>()); 

Si su objetivo es la inicialización perezosa y sin NPE usted tiene que crear su propio mapa:

private static abstract class MyMap<K, V> extends HashMap<K, V> { 
    @Override 
    public V get(Object key) { 
     V val = super.get(key); 
     if (val == null && key instanceof K) { 
      put((K)key, val = create()); 
     } 
     return val; 
    } 

    protected abstract V create(); 
} 


public void initialize() { 
    properties = new MyMap<String, Map<String, Map<String, String>>>() { 
     @Override 
     protected Map<String, Map<String, String>> create() { 
      return new MyMap<String, Map<String, String>>() { 
       @Override 
       protected Map<String, String> create() { 
        return new HashMap<String, String>(); 
       } 
      }; 
     } 
    }; 

} 

Answer 2

La única manera de hacerlo con esta estructura es preinicializar los mapas de 1er y 2 ° nivel con TODAS las teclas posibles. Si esto no es posible, no puede lograr lo que está pidiendo con Mapas simples.

Como alternativa, puede crear una estructura de datos personalizada que sea más indulgente. Por ejemplo, un truco común es que una búsqueda de clave fallida devuelva una estructura "vacía" en lugar de nula, lo que permite el acceso anidado.

Answer 3

Me parece que usted necesita para crear su propia clase Key:

public class Key { 
    private final String a; 
    private final String b; 
    private final String c; 
    public Key(String a, String b, String c) { 
     // initialize all fields here 
    } 

    // you need to implement equals and hashcode. Eclipse and IntelliJ can do that for you 
} 

Si implementa su propia clase de clave, su mapa se verá así:

Map<Key, String> map = new HashMap<Key, String>(); 

Y cuando se busca algo en el mapa se puede utilizar:

map.get(new Key("a", "b", "c")); 

El método anterior no va a lanzar una NullPointerException.

Recuerde que para que esta solución funcione, debe anular equals y hashcode en la clase Key. Hay ayuda here. Si no reemplaza equals y hashcode, entonces una nueva clave con los mismos elementos no coincidirá con una clave existente en el mapa.

Existen otras soluciones posibles, pero la implementación de su propia clave es bastante limpia en mi opinión. Si no desea utilizar el constructor puede inicializar su clave con un método estático y usar algo como:

Key.build(a, b, c) 

Depende de usted.

Answer 4

No puede inicializar esto de una vez, ya que normalmente no sabe qué teclas tendrá de antemano.

Por lo tanto, debe comprobar si el submapa de una clave es nulo y, si es así, podría agregar un mapa vacío para eso.Preferiblemente, solo lo haría al agregar entradas al mapa y al recuperar las entradas devolverá nulo si uno de los submapas en la ruta no existe. Puede envolver eso en su propia implementación de mapas para facilitar su uso.

Como alternativa, las colecciones de apache commons 'MultiKeyMap pueden proporcionar lo que desee.

Answer 5

Es imposible usar properties.get("a").get("b").get("c"); y asegúrese de evitar null a menos que haga su propio Mapa. De hecho, no puede predecir que su mapa contendrá la tecla "b". Así que intente crear su propia clase para manejar el get anidado.

Answer 6

Creo que una mejor solución es usar un objeto como la única clave para el mapa de valores. La clave estará compuesta por tres campos, state, transition y property.

import org.apache.commons.lang3.builder.EqualsBuilder; 
import org.apache.commons.lang3.builder.HashCodeBuilder; 

public class Key { 

    private String state; 

    private String transition; 

    private String property; 

    public Key(String state, String transition, String property) { 
     this.state = state; 
     this.transition = transition; 
     this.property = property; 
    } 

    @Override 
    public boolean equals(Object other) { 
     return EqualsBuilder.reflectionEquals(this, other); 
    } 

    @Override 
    public int hashCode() { 
     return HashCodeBuilder.reflectionHashCode(this); 
    } 

} 

Cuando busca un valor, el mapa volverá null para una llave que no está asociado con un valor

Map<Key, String> values = new HashMap<Key, String>(); 
assert values.get(new Key("a", "b", "c")) == null; 

values.put(new Key("a", "b", "c"), "value"); 
assert values.get(new Key("a", "b", "c")) != null; 
assert values.get(new Key("a", "b", "c")).equals("value"); 

Para utilizar de manera eficiente y correctamente un objeto como una llave en una Map se debe anular los métodos equals() y hashCode(). He creado estos métodos usando las funcionalidades reflexivas de la biblioteca Commons Lang.

Answer 7

Se puede usar un método de utilidad:

public static <T> T get(Map<?, ?> properties, Object... keys) { 
    Map<?, ?> nestedMap = properties; 
    for (int i = 0; i < keys.length; i++) { 
     if (i == keys.length - 1) { 
     @SuppressWarnings("unchecked") 
     T value = (T) nestedMap.get(keys[i]); 
     return value; 
     } else { 
     nestedMap = (Map<?, ?>) nestedMap.get(keys[i]); 
     if(nestedMap == null) { 
      return null; 
     } 
     } 
    } 
    return null; 
    } 

Esto puede ser invocada como esto:

String result = get(properties, "a", "b", "c"); 

Tenga en cuenta que es necesario tener cuidado al usar este ya que no es de tipo seguro.