What happens when a duplicate key is put into a HashMap?

Если я передам один и тот же ключ несколько раз методу HashMap’s put, что произойдет с исходным значением? И что, если даже значение повторится? Я не нашел никакой документации по этому поводу.

Пример 1: Перезаписанные значения для ключа

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.

Случай 2: дублирующее значение

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

Получаем one.

Но что происходит с другими значениями? Я преподавал основы студенту, и меня спросили об этом. Это Map похоже на корзину, где упоминается последнее значение (но в памяти)?

По определению, команда put заменяет предыдущее значение, связанное с данным ключом в map (концептуально похоже на операцию индексации массива для примитивных типов).

Карта просто удаляет ссылку на значение. Если ничто другое не содержит ссылки на объект, этот объект становится пригодным для сборки мусора. Кроме того, Java возвращает любое предыдущее значение, связанное с данным ключом (или null если его нет), так что вы можете определить, что там было, и при необходимости сохранить ссылку.

Дополнительная информация здесь: Документ о хэш-карте

Вы можете найти свой ответ в javadoc из Map#put(K, V) (который на самом деле что-то возвращает):

public V put(K key,
             V value)

Указанное значение связывается с указанным ключом в этой карте
(необязательная операция). Если карта
ранее содержала сопоставление для
этого ключа, старое значение заменяется на
указанное значение. (Говорят, что карта m
содержит отображение для ключа, kесли
и только если m.containsKey(k)будет
возвращать true.)

Параметры:

key - ключ, с которым должно быть связано указанное значение.

value - значение, которое должно быть связано с указанным ключом.

ВОЗВРАТ:
предыдущее значение, связанное с указанным ключом, или null если для key не было сопоставления. (null Возврат также может указывать на то, что карта ранее была связана null с указанным key, если реализация поддерживает null значения.)

Итак, если вы не присваиваете возвращаемое значение при вызове mymap.put("1", "a string"), на него просто не ссылаются и, следовательно, он подходит для сборки мусора.

это функция ключа / значения, и вы не могли бы иметь дубликат ключа для нескольких значений, потому что, когда вы хотите получить фактическое значение, какое из значений принадлежит введенному ключу
в вашем примере, когда вы хотите получить значение "1", какое именно ?!
это причины иметь уникальный ключ для каждого значения, но вы могли бы использовать трюк со стандартной библиотекой 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);
    }
}

и вы могли бы использовать это таким образом:

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

и результатом печати являются :

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

Он заменяет существующее значение в map на соответствующий ключ. И если не существует ключа с таким же именем, то создается ключ с указанным значением. например:

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

ВЫВОД
ключ = "1", значение = "два"

Итак, предыдущее значение перезаписывается.