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




example duplicate (9)

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


Answers

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.


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

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

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

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



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.


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


puedes hacer eso

HashMap<Integer,Integer> hm = new HashMap<Integer,Integer>();
hm.put(1,10);
hm.put(2,45);
hm.put(3,100);
Iterator<Integer> it = hm.keySet().iterator();
Integer fk = it.next();
Integer max = hm.get(fk);
while(it.hasNext()) {
    Integer k = it.next();
    Integer val = hm.get(k);
    if (val > max){
         max = val;
         fk=k;
    }
}
System.out.println("Max Value "+max+" is associated with "+fk+" key");






java hashmap hashtable