java - keys - ¿Qué sucede cuando una clave duplicada se coloca en un HashMap?

map java example

Question

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

Answer 1

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

Answer 2

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.

Answer 3

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

Answer 4

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.

Answer 5

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

Answer 6

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 m contiene una asignación para una clave k si y solo si m.containsKey(k) devolvería true ).

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, o null si no había asignación para la key . (Un retorno null también puede indicar que el mapa asociado previamente a null con la key especificada, si la implementación admite valores null ).

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.

Answer 7

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.

Answer 8

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

Answer 9

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

Answer 10

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