Могут ли повторяться ключи в Map

Могут ли повторяться ключи в Map

Нет, ключи в Map не могут повторяться. Это фундаментальное свойство структуры данных Map. Если попробуешь добавить значение с существующим ключом — старое значение перезапишется.

Как работает Map с уникальностью ключей

Вставка с существующим ключом

Map<String, Integer> map = new HashMap<>();

// Первая вставка
map.put("apple", 5);
System.out.println(map); // {apple=5}

// Вторая вставка с ТЕМ ЖЕ ключом
map.put("apple", 10);
System.out.println(map); // {apple=10} — ПЕРЕЗАПИ...

// Размер остался 1, не 2
System.out.println(map.size()); // 1

Правило: Map может содержать максимум одно значение для каждого ключа.

Возврат старого значения

Map<String, String> map = new HashMap<>();

String old1 = map.put("key", "first");
System.out.println(old1); // null (ключа не было)

String old2 = map.put("key", "second");
System.out.println(old2); // "first" (старое значение)

Внутренняя реализация (HashMap)

Проверка существования

HashMap гарантирует уникальность через:

1. Hash функцию — преобразует key в индекс массива
2. Equals метод — проверяет, есть ли такой ключ в корзине

public V put(K key, V value) {
    // 1. Вычисляем hash
    int hash = hash(key);
    int index = hash % table.length;
    
    // 2. Ищем ключ в цепочке коллизий
    Entry<K, V> entry = table[index];
    while (entry != null) {
        if (entry.key.equals(key)) { // найден!
            V oldValue = entry.value;
            entry.value = value; // ПЕРЕЗАПИСЫВАЕМ
            return oldValue;
        }
        entry = entry.next;
    }
    
    // 3. Не нашли — добавляем новый
    addEntry(key, value, index);
    return null;
}

Ключевой момент: entry.key.equals(key) — проверка на уникальность.

Правильная реализация equals и hashCode

Для custom объектов как ключи — обязательно реализовать оба метода:

public class User {
    private Long id;
    private String name;
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(id, user.id); // сравниваем по ID
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(id); // хеш тоже по ID
    }
}

// Использование
Map<User, String> userMap = new HashMap<>();
User user1 = new User(1L, "John");
User user1_duplicate = new User(1L, "John");

userMap.put(user1, "value1");
userMap.put(user1_duplicate, "value2"); // ПЕРЕЗАПИШЕТ!

System.out.println(userMap.size()); // 1, не 2!

Важно: если equals() вернёт true для двух объектов, они считаются одним ключом.

Типы Map и уникальность

Все типы гарантируют: максимум одно значение на ключ.

Что повторяться может: значения

Значения (values) могут повторяться:

Map<String, Integer> map = new HashMap<>();

map.put("apple", 5);
map.put("orange", 5);  // ТОТ ЖЕ value (5), но РАЗНЫЕ ключи
map.put("banana", 5);  // снова 5

System.out.println(map.size()); // 3 (три разных ключа)
System.out.println(map.values()); // [5, 5, 5]

Для гарантии уникальности значений используй обратную Map:

Map<String, Integer> forward = new HashMap<>();
Map<Integer, String> reverse = new HashMap<>();

forward.put("apple", 5);
reverse.put(5, "apple");

forward.put("orange", 5);
// Попытка обратить: reverse.put(5, "orange") — ПЕРЕЗАПИШЕТ!

Практический пример: кэш с проверкой уникальности

public class UserCache {
    private final Map<Long, User> cache = new HashMap<>();
    
    public void addUser(User user) {
        Long id = user.getId();
        
        // Проверяем, есть ли уже такой ID
        if (cache.containsKey(id)) {
            User existing = cache.get(id);
            System.out.println("User " + id + " already exists");
            // Перезаписываем или игнорируем?
            cache.put(id, user); // перезаписываем
            return;
        }
        
        cache.put(id, user);
    }
    
    public User get(Long id) {
        return cache.get(id); // максимум одного значения
    }
}

// Usage
UserCache cache = new UserCache();
cache.addUser(new User(1L, "John"));
cache.addUser(new User(1L, "Jane")); // перезапишет

System.out.println(cache.get(1L).getName()); // "Jane"

Ошибки и подводные камни

Ошибка 1: Неправильный equals/hashCode

public class BuggyUser {
    private Long id;
    
    // НЕПРАВИЛЬНО: забыл переопределить equals
    // equals по умолчанию — это ==, проверка по ссылке!
    
    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

// Результат
Map<BuggyUser, String> map = new HashMap<>();
BuggyUser user1 = new BuggyUser(1L);
BuggyUser user2 = new BuggyUser(1L); // разные объекты!

map.put(user1, "value1");
map.put(user2, "value2"); // ДОБАВИТ, не перезапишет!

System.out.println(map.size()); // 2! Ошибка!

Исправление: всегда реализовывай equals() и hashCode() вместе.

Ошибка 2: Изменение ключа после вставки

public class MutableKey {
    private String value;
    
    public MutableKey(String value) {
        this.value = value;
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
    
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof MutableKey)) return false;
        return value.equals(((MutableKey) o).value);
    }
    
    public void setValue(String newValue) {
        this.value = newValue; // ОПАСНО!
    }
}

// Проблема
Map<MutableKey, String> map = new HashMap<>();
MutableKey key = new MutableKey("original");
map.put(key, "value");

key.setValue("changed"); // хеш ИЗМЕНИЛСЯ

// Теперь мы не можем найти значение!
System.out.println(map.get(key)); // null
System.out.println(map.size()); // 1 (но не можем достать)

Решение: ключи должны быть immutable (неизменяемы).

Правильный ответ на собеседовании

"Нет, ключи в Map не могут повторяться. Это гарантируется структурой:

• HashMap использует hash функцию и equals() для проверки уникальности
• Если добавить значение с существующим ключом — старое перезапишется
• Ключи должны быть immutable (неизменяемы)
• equals() и hashCode() всегда вместе

Значения могут повторяться, но ключи — нет.

Правило: put(key, value)

• Если key не существует → добавить
• Если key существует → перезаписать и вернуть старое значение"