elementos - map java example
Verificación de existencia clave en HashMap. (9)
- Si la clase clave es su, asegúrese de que los métodos hashCode () y equals () estén implementados.
- Básicamente, el acceso a HashMap debe ser O (1), pero con la implementación incorrecta del método hashCode se convierte en O (n), porque el valor con la misma clave hash se almacenará como lista vinculada.
¿Siempre es necesario verificar la existencia clave en HashMap?
Tengo un HashMap con, por ejemplo, 1000 entradas y estoy buscando mejorar la eficiencia. Si se accede al HashMap con mucha frecuencia, la verificación de la existencia clave en cada acceso dará lugar a una gran sobrecarga. En cambio, si la clave no está presente y, por lo tanto, se produce una excepción, puedo detectar la excepción. (Cuando sé que esto sucederá raramente). Esto reducirá los accesos al HashMap a la mitad.
Puede que esta no sea una buena práctica de programación, pero me ayudará a reducir el número de accesos. ¿O me estoy perdiendo algo aquí?
[ Actualización ] No tengo valores nulos en el HashMap.
¿Alguna vez almacenas un valor nulo? Si no, simplemente puedes hacer:
Foo value = map.get(key);
if (value != null) {
...
} else {
// No such key
}
De lo contrario, puede verificar la existencia si obtiene un valor nulo devuelto:
Foo value = map.get(key);
if (value != null) {
...
} else {
// Key might be present...
if (map.containsKey(key)) {
// Okay, there''s a key but the value is null
} else {
// Definitely no such key
}
}
¿Quieres decir que tienes código como
if(map.containsKey(key)) doSomethingWith(map.get(key))
por todo el lugar ? Entonces deberías simplemente verificar si map.get(key) devolvió un valor nulo y eso es todo. Por cierto, HashMap no lanza excepciones para las claves faltantes, sino que devuelve null. El único caso en el que se necesitatainsKey es cuando almacena valores nulos, para distinguir entre un valor nulo y un valor faltante, pero esto generalmente se considera una mala práctica.
No ganarás nada comprobando que la clave existe. Este es el código de HashMap :
@Override
public boolean containsKey(Object key) {
Entry<K, V> m = getEntry(key);
return m != null;
}
@Override
public V get(Object key) {
Entry<K, V> m = getEntry(key);
if (m != null) {
return m.value;
}
return null;
}
Solo verifique si el valor de retorno para get() es diferente de null .
Este es el código fuente de HashMap.
Recursos:
Sólo tiene que containsKey() para mayor claridad. Es rápido y mantiene el código limpio y legible. El punto HashMap de HashMap s es que la búsqueda de claves es rápida, solo asegúrese de que hashCode() y equals() estén correctamente implementados.
Una mejor manera es utilizar el método de HashMap. Mañana, la asociación agregará un valor nulo al mapa, debe diferenciar entre la clave allí y la clave tiene un valor nulo.
Usualmente uso el idioma
Object value = map.get(key);
if (value == null) {
value = createValue(key);
map.put(key, value);
}
Esto significa que solo golpeas el mapa dos veces si falta la clave
La respuesta de Jon Skeet aborda bien los dos escenarios (mapa con valor null y no valor null ) de una manera eficiente.
Acerca de las entradas de números y la preocupación de eficiencia, me gustaría agregar algo.
Tengo un HashMap con, digamos, 1.000 entradas y estoy buscando mejorar la eficiencia. Si se accede al HashMap con mucha frecuencia, la verificación de la existencia clave en cada acceso dará lugar a una gran sobrecarga.
Un mapa con 1.000 entradas no es un mapa enorme.
Así como un mapa con 5.000 o 10.000 entradas.
Map están diseñados para hacer una recuperación rápida con tales dimensiones.
Ahora, asume que hashCode() de las claves del mapa proporciona una buena distribución.
Si puedes usar un Integer como tipo de clave, hazlo.
Su método hashCode() es muy eficiente ya que las colisiones no son posibles para valores int únicos:
public final class Integer extends Number implements Comparable<Integer> {
...
@Override
public int hashCode() {
return Integer.hashCode(value);
}
public static int hashCode(int value) {
return value;
}
...
}
Si para la clave, tiene que usar otro tipo incorporado como String por ejemplo, que a menudo se usa en el Map , puede tener algunas colisiones pero de 1 mil a algunos miles de objetos en el Map , debería tener muy pocas. como el método String.hashCode() proporciona una buena distribución.
Si usa un tipo personalizado, sobrescriba hashCode() y equals() correctamente y asegúrese de que, en general, hashCode() proporcione una distribución justa.
Puede referirse al ítem 9 de Java Effective refiere.
Aquí hay una post que detalla el camino.
if(map.get(key) != null || (map.get(key) == null && map.containsKey(key)))