O que acontece quando uma chave duplicada é colocada em um HashMap?

Se eu passar a mesma chave várias vezes para HashMapo putmétodo, o que acontece com o valor original? E se o valor se repetir? Não encontrei nenhuma documentação sobre isso.

Caso 1: Valores sobrescritos para uma chave

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

Nós recebemos 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"));

Nós recebemos one.

Mas o que acontece com os outros valores? Eu estava ensinando básico a um aluno e me perguntaram isso. É Mapcomo um balde em que o último valor é referenciado (mas na memória)?

Por definição, o putcomando substitui o valor anterior associado à chave fornecida no mapa (conceitualmente como uma operação de indexação de matriz para tipos primitivos).

O mapa simplesmente elimina sua referência ao valor. Se nada mais contiver uma referência ao objeto, esse objeto se tornará elegível para a coleta de lixo. Além disso, Java retorna qualquer valor anterior associado à chave fornecida (ou nullse não houver nenhum), para que você possa determinar o que estava lá e manter uma referência, se necessário.

Mais informações aqui: HashMap Doc

Você pode encontrar sua resposta no javadoc do Mapa # put (K, V) (que realmente retorna algo):

public V put(K key,
             V value)

Associa o valor especificado à chave especificada neste mapa (operação opcional). Se o mapa continha anteriormente um mapeamento para essa chave, o valor antigo será substituído pelo valor especificado. ( mDiz-se que um mapa contém um mapeamento para uma chave kse, e somente se m.containsKey(k), retornaria true.)

Parâmetros:
key - chave à qual o valor especificado deve ser associado.
value- valor a ser associado à chave especificada.

Retorna:
valor anterior associado à chave especificada ou nullse não houve mapeamento para key. (Um nullretorno também pode indicar que o mapa anteriormente associado nullao especificado key, se a implementação suportar nullvalores.)

Portanto, se você não atribuir o valor retornado ao chamar mymap.put("1", "a string"), ele se tornará não referenciado e, portanto, elegível para a coleta de lixo.

O valor anterior da chave é descartado e substituído pelo novo.

Se você deseja manter todos os valores fornecidos por uma chave, considere implementar algo como isto:

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

é o recurso Chave / Valor e você não pode ter uma chave duplicada para vários valores, porque quando você deseja obter o valor real de qual um dos valores pertence à chave inserida
no seu exemplo, quando deseja obter o valor "1", qual é isto ?!
é por isso que temos uma chave exclusiva para cada valor, mas você pode ter um truque usando a java standard lib:

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

e você poderia usá-lo desta maneira:

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

e o resultado das impressões são:

[one, not one, surely not one]
not one
null

Associa o valor especificado à chave especificada neste mapa. Se o mapa continha anteriormente um mapeamento para a chave, o valor antigo será substituído.

Ele substitui o valor existente no mapa pela respectiva chave. E se nenhuma chave existir com o mesmo nome, ela criará uma chave com o valor fornecido. por exemplo:

Map mymap = new HashMap();
mymap.put("1","one");
mymap.put("1","two");

Tecla OUTPUT = "1", valor = "dois"

Portanto, o valor anterior é substituído.

Para sua pergunta se o mapa era como um balde: não.

É como uma lista com name=valuepares, embora namenão precise ser uma String (pode).

Para obter um elemento, você passa sua chave para o método get () - que fornece o objeto atribuído em troca.

E um mapa Hash significa que, se você estiver tentando recuperar seu objeto usando o método get, ele não comparará o objeto real com o que você forneceu, porque precisaria percorrer sua lista e comparar () a chave você forneceu o elemento atual.

Isso seria ineficiente. Em vez disso, não importa em que consiste seu objeto, ele calcula o chamado código hash dos dois objetos e os compara. É mais fácil comparar dois ints em vez de dois objetos inteiros (possivelmente profundamente complexos). Você pode imaginar o código de hash como um resumo com um comprimento predefinido (int); portanto, ele não é único e possui colisões. Você encontra as regras para o hashcode na documentação na qual inseri o link.

Se você quiser saber mais sobre isso, consulte os artigos em javapractices.com e technofundo.com

Saudações

Eu sempre usei:

HashMap<String, ArrayList<String>> hashy = new HashMap<String, ArrayList<String>>();

se eu quisesse aplicar várias coisas a uma chave de identificação.

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

}

você sempre pode fazer algo assim e criar um labirinto!

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

Os mapas do JDK não se destinam ao armazenamento de dados sob chaves duplicadas.

• Na melhor das hipóteses, o novo valor substituirá os anteriores.

• O pior cenário é a exceção (por exemplo, quando você tenta coletá-lo como um fluxo):

Sem duplicatas:

Stream.of("one").collect(Collectors.toMap(x -> x, x -> x))

Está bem. Você receberá: $ 2 ==> {one = one}

Fluxo duplicado:

Stream.of("one", "not one", "surely not one").collect(Collectors.toMap(x -> 1, x -> x))

Exceção java.lang.IllegalStateException: Chave duplicada 1 (tentativa de mesclar valores um e não um) | em Collectors.duplicateKeyException (Collectors.java:133) | em Collectors.lambda $ uniqKeysMapAccumulator $ 1 (Collectors.java:180) | em ReduceOps $ 3ReducingSink.accept (ReduceOps.java:169) | em Spliterators $ ArraySpliterator.forEachRemaining (Spliterators.java:948) | em AbstractPipeline.copyInto (AbstractPipeline.java:484) | em AbstractPipeline.wrapAndCopyInto (AbstractPipeline.java:474) | em ReduceOps $ ReduceOp.evaluateSequential (ReduceOps.java:913) | em AbstractPipeline.evaluate (AbstractPipeline.java:234) | em ReferencePipeline.collect (ReferencePipeline.java:578) | em (# 4: 1)

Para lidar com chaves duplicadas - use outro pacote, por exemplo: https://google.github.io/guava/releases/19.0/api/docs/com/google/common/collect/Multimap.html

Existem muitas outras implementações que lidam com chaves duplicadas. Eles são necessários para a web (por exemplo, chaves de cookies duplicadas, cabeçalhos de HTTP podem ter os mesmos campos, ...)

Boa sorte! :)

BTW, se você quiser alguma semântica, como colocar apenas se essa chave não existir. você pode usar concurrentHashMapcom a putIfAbsent()função Veja isso:

https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ConcurrentHashMap.html#put(K,%20V)

concurrentHashMap é seguro para threads com alto desempenho, pois usa o mecanismo de " bloqueio de distribuição " para melhorar a taxa de transferência.

Sim, isso significa que todas as 1 chaves com valor são substituídas pelo último valor adicionado e aqui você adiciona "certamente não uma", para exibir apenas "certamente não uma".

Mesmo se você estiver tentando exibir com um loop, ele também exibirá apenas uma chave e valor com a mesma chave.

         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

Significa que o mapa de hash não permitirá duplicatas, se você tiver substituído corretamente os métodos equals e hashCode ().

O HashSet também usa o HashMap internamente, consulte o documento de origem

public class HashSet{
public HashSet() {
        map = new HashMap<>();
    }
}