java - keys - ¿Qué sucede cuando una clave duplicada se coloca en un HashMap?
map java example (10)
Si paso la misma clave varias veces al método put HashMap , ¿qué sucede con el valor original? ¿Y si incluso el valor se repite? No encontré ninguna documentación sobre esto.
Caso 1: Valores sobrescritos para una clave
Map mymap = new HashMap();
mymap.put("1","one");
mymap.put("1","not one");
mymap.put("1","surely not one");
System.out.println(mymap.get("1"));
surely not one obtengamos surely not one .
Caso 2: valor duplicado
Map mymap = new HashMap();
mymap.put("1","one");
mymap.put("1","not one");
mymap.put("1","surely not one");
// The following line was added:
mymap.put("1","one");
System.out.println(mymap.get("1"));
Conseguimos one .
¿Pero qué pasa con los otros valores? Estaba enseñando conceptos básicos a un estudiante y me preguntaron esto. ¿El Map como un cubo donde se hace referencia al último valor (pero en la memoria)?
A tu pregunta si el mapa era como un cubo: no.
Es como una lista con pares name=value mientras que el name no necesita ser una cadena (aunque puede serlo).
Para obtener un elemento, debe pasar su clave al método get (), que le proporciona el objeto asignado a cambio.
Y un mapa Hash significa que si está intentando recuperar su objeto utilizando el método get, no comparará el objeto real con el que proporcionó, ya que tendría que recorrer su lista y comparar () la clave. Usted proporcionó con el elemento actual.
Esto sería ineficiente. En cambio, no importa en qué consiste su objeto, calcula un llamado código de hash de ambos objetos y los compara. Es más fácil comparar dos int s en lugar de dos objetos completos (posiblemente profundamente complejos). Puede imaginar el código hash como un resumen con una longitud predefinida (int), por lo tanto, no es único y tiene colisiones. Encontrará las reglas para el código hash en la documentación en la que he insertado el enlace.
Si desea saber más acerca de esto, puede consultar los artículos en javapractices.com y technofundo.com
Saludos
Asocia el valor especificado con la clave especificada en este mapa. Si el mapa contenía previamente una asignación para la clave, se reemplaza el valor anterior.
El valor anterior de la clave se elimina y se reemplaza por el nuevo.
Si desea conservar todos los valores que se proporcionan con una clave, podría considerar implementar algo como esto:
import org.apache.commons.collections.MultiHashMap;
import java.util.Set;
import java.util.Map;
import java.util.Iterator;
import java.util.List;
public class MultiMapExample {
public static void main(String[] args) {
MultiHashMap mp=new MultiHashMap();
mp.put("a", 10);
mp.put("a", 11);
mp.put("a", 12);
mp.put("b", 13);
mp.put("c", 14);
mp.put("e", 15);
List list = null;
Set set = mp.entrySet();
Iterator i = set.iterator();
while(i.hasNext()) {
Map.Entry me = (Map.Entry)i.next();
list=(List)mp.get(me.getKey());
for(int j=0;j<list.size();j++)
{
System.out.println(me.getKey()+": value :"+list.get(j));
}
}
}
}
Por cierto, si desea alguna semántica como solo poner si esta clave no existe. puede usar concurrentHashMap con la función putIfAbsent() . Mira esto:
https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ConcurrentHashMap.html#put(K,%20V)
concurrentHashMap es seguro para subprocesos con alto rendimiento, ya que utiliza el mecanismo de " bloqueo de trazado de líneas " para mejorar el rendimiento.
Por definición, el comando put reemplaza el valor anterior asociado con la clave dada en el mapa (conceptualmente como una operación de indexación de matriz para tipos primitivos).
El mapa simplemente cae su referencia al valor. Si nada más contiene una referencia al objeto, ese objeto se vuelve elegible para la recolección de basura. Además, Java devuelve cualquier valor anterior asociado con la clave dada (o null si no está presente), por lo que puede determinar qué había allí y mantener una referencia si es necesario.
Más información aquí: HashMap Doc
Puede encontrar su respuesta en el javadoc de Map # put (K, V) (que en realidad devuelve algo):
public V put(K key, V value)Asocia el valor especificado con la clave especificada en este mapa (operación opcional). Si el mapa contenía previamente una asignación para esta clave, el valor anterior se reemplaza por el valor especificado. (Se dice que un mapa
mcontiene una asignación para una claveksi y solo sim.containsKey(k)devolveríatrue).Parámetros:
key- clave con la que se va a asociar el valor especificado.
value- valor que se asocia con la clave especificada.Devoluciones:
el valor anterior asociado con la clave especificada, onullsi no había asignación para lakey. (Un retornonulltambién puede indicar que el mapa asociado previamente anullcon lakeyespecificada, si la implementación admite valoresnull).
Por lo tanto, si no asigna el valor devuelto cuando llama a mymap.put("1", "a string") , simplemente no se hace referencia y, por lo tanto, es elegible para la recolección de basura.
Sí, esto significa que todas las 1 teclas con valor se sobrescriben con el último valor agregado y aquí se agrega "seguramente no una", por lo que solo se mostrará "seguramente no una".
Incluso si está intentando mostrar con un bucle, también mostrará solo una clave y un valor que tienen la misma clave.
Siempre he usado
HashMap<String, ArrayList<String>> hashy = new HashMap<String, ArrayList<String>>();
Si quisiera aplicar varias cosas a una clave de identificación.
public void MultiHash(){
HashMap<String, ArrayList<String>> hashy = new HashMap<String, ArrayList<String>>();
String key = "Your key";
ArrayList<String> yourarraylist = hashy.get(key);
for(String valuessaved2key : yourarraylist){
System.out.println(valuessaved2key);
}
}
¡Siempre podrías hacer algo como esto y crearte un laberinto!
public void LOOK_AT_ALL_THESE_HASHMAPS(){
HashMap<String, HashMap<String, HashMap<String, HashMap<String, String>>>> theultimatehashmap = new HashMap <String, HashMap<String, HashMap<String, HashMap<String, String>>>>();
String ballsdeep_into_the_hashmap = theultimatehashmap.get("firststring").get("secondstring").get("thirdstring").get("forthstring");
}
es la característica Clave / Valor y no se puede tener una clave duplicada para varios valores porque cuando se desea obtener el valor real a cuál de los valores pertenece la clave ingresada
en tu ejemplo, cuando quieres obtener el valor de "1", ¿cuál es?
Esas son las razones para tener una clave única para cada valor, pero podría tener un truco con la versión estándar de Java:
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
public class DuplicateMap<K, V> {
private Map<K, ArrayList<V>> m = new HashMap<>();
public void put(K k, V v) {
if (m.containsKey(k)) {
m.get(k).add(v);
} else {
ArrayList<V> arr = new ArrayList<>();
arr.add(v);
m.put(k, arr);
}
}
public ArrayList<V> get(K k) {
return m.get(k);
}
public V get(K k, int index) {
return m.get(k).size()-1 < index ? null : m.get(k).get(index);
}
}
y podrías usarlo de esta manera:
public static void main(String[] args) {
DuplicateMap<String,String> dm=new DuplicateMap<>();
dm.put("1", "one");
dm.put("1", "not one");
dm.put("1", "surely not one");
System.out.println(dm.get("1"));
System.out.println(dm.get("1",1));
System.out.println(dm.get("1", 5));
}
Y el resultado de las impresiones son:
[one, not one, surely not one]
not one
null
HashMap<Emp, Emp> empHashMap = new HashMap<Emp, Emp>();
empHashMap.put(new Emp(1), new Emp(1));
empHashMap.put(new Emp(1), new Emp(1));
empHashMap.put(new Emp(1), new Emp());
empHashMap.put(new Emp(1), new Emp());
System.out.println(empHashMap.size());
}
}
class Emp{
public Emp(){
}
public Emp(int id){
this.id = id;
}
public int id;
@Override
public boolean equals(Object obj) {
return this.id == ((Emp)obj).id;
}
@Override
public int hashCode() {
return id;
}
}
OUTPUT : is 1
El mapa hash de medios no permitirá duplicados, si ha reemplazado correctamente los métodos equals y hashCode ().
HashSet también usa HashMap internamente, consulte el documento de origen
public class HashSet{
public HashSet() {
map = new HashMap<>();
}
}