Какое значение останется в HashMap, если добавить идентичный уже имеющемуся ключ?

Краткий ответ

Если добавить в HashMap (или любой класс, реализующий интерфейс Map в Java) пару ключ-значение с ключом, который уже присутствует в коллекции, то старое значение будет заменено новым. Ключ при этом остаётся прежним, меняется только связанное с ним значение. Это фундаментальное поведение, определенное контрактом интерфейса Map.

Детальное объяснение

HashMap в Java — это реализация интерфейса Map<K,V>, который представляет собой коллекцию пар "ключ-значение", где каждый ключ должен быть уникальным. Основное правило: один ключ — одно значение.

Механизм работы метода put()

Когда вы вызываете метод map.put(key, value):

1. Вычисляется хэш-код ключа (с помощью метода hashCode()).
2. На основе хэш-кода определяется "корзина" (bucket), в которую будет помещена запись.
3. Происходит проверка на коллизию внутри корзины: если в ней уже есть запись с таким же ключом (проверка выполняется сначала по хэш-коду, а затем с помощью метода equals() для гарантии точного совпадения), то:

    *   **Новое значение заменяет старое**.
    *   **Метод `put()` возвращает старое значение**, которое было связано с этим ключом.

1. Если ключ уникален (в корзине нет equals-эквивалентного ключа), то создаётся новая запись (узел Node<K,V>), и метод возвращает null.

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        
        // Первое добавление ключа "apple"
        Integer oldValue1 = map.put("apple", 100);
        System.out.println("Первое добавление 'apple'. Возвращено: " + oldValue1); // null
        System.out.println("map: " + map); // {apple=100}
        
        // Добавление (замена) значения для существующего ключа "apple"
        Integer oldValue2 = map.put("apple", 250);
        System.out.println("\nВторое добавление 'apple'. Возвращено (старое значение): " + oldValue2); // 100
        System.out.println("map: " + map); // {apple=250}
        
        // Проверка текущего значения
        System.out.println("\nТекущее значение для 'apple': " + map.get("apple")); // 250
    }
}

Вывод программы:

Первое добавление 'apple'. Возвращено: null
map: {apple=100}

Второе добавление 'apple'. Возвращено (старое значение): 100
map: {apple=250}

Текущее значение для 'apple': 250

Почему так работает? Контракт интерфейса Map

Это поведение не является особенностью HashMap. Оно прямо указано в документации (javadoc) интерфейса java.util.Map для метода V put(K key, V value):

If the map previously contained a mapping for the key, the old value is replaced by the specified value.

Основные последствия и причины такого дизайна:

• Гарантируется уникальность ключей. Карта — это не коллекция пар, а именно отображение ключей на значения.
• Предсказуемость обновления данных. Это позволяет легко обновлять значение, ассоциированное с ключом, без необходимости предварительного удаления.
• Возможность получить старое значение через возвращаемое значение метода put() полезно для многих алгоритмов.

Важные нюансы для понимания

1. Ключевая роль методов hashCode() и equals(). Замена произойдет только если ключи идентичны с точки зрения метода equals(). Для корректных пользовательских объектов, используемых в качестве ключей, эти методы должны быть правильно переопределены.
2. Отличие от Set. В HashSet (который внутри использует HashMap) при попытке добавить существующий элемент ничего не происходит, и метод add() возвращает false. В Map меняется значение, а ключ остается.
3. Альтернативный метод putIfAbsent(). Начиная с Java 8, если нужно добавить значение только если ключ отсутствует, следует использовать метод putIfAbsent(K key, V value). Он заменяет значение только в случае, если ключ еще не был связан со значением (или был связан с null).

   map.putIfAbsent("apple", 500); // Ничего не изменится, т.к. "apple" уже существует
   System.out.println(map.get("apple")); // Осталось 250
   

Практическое значение для QA Automation

Понимание этого поведения критически важно при:

• Написании и анализе тестов. Нужно четко понимать, какое конечное состояние коллекции ожидается после серии операций put.
• Работе с кэшами или хранилищами в памяти, которые часто реализованы на основе HashMap (например, хранение параметров тестовых сессий).
• Отладке. Если значение по известному ключу неожиданно изменилось, причиной, скорее всего, является повторный вызов put() с тем же ключом.

Итог: В HashMap (и других реализациях Map) ключ уникален. Добавление записи с уже существующим ключом приводит не к созданию дубликата, а к обновлению значения, связанного с этим ключом. Старое значение при этом безвозвратно теряется (если только не сохранено через возвращаемое значение метода put).