Как обеспечить уникальность значения ключа в HashMap

Обеспечение уникальности ключей в HashMap

HashMap - это одна из наиболее используемых коллекций в Java, которая хранит пары ключ-значение. Уникальность ключей является фундаментальным требованием для правильной работы HashMap.

1. Естественная уникальность HashMap

// HashMap гарантирует уникальность ключей по умолчанию
Map<String, Integer> map = new HashMap<>();

// Добавляем первый ключ
map.put("user1", 100);
map.put("user2", 200);
map.put("user3", 300);

// При добавлении существующего ключа - старое значение перезаписывается
map.put("user1", 150);  // user1 теперь имеет значение 150

System.out.println(map.size()); // 3 (не 4)
System.out.println(map); // {user1=150, user2=200, user3=300}

2. Правильная реализация hashCode() и equals()

// Неправильная реализация
public class BadUser {
    private Long id;
    private String name;
    
    public BadUser(Long id, String name) {
        this.id = id;
        this.name = name;
    }
    
    // Забыли переопределить hashCode() и equals()
    // Java использует identity (памяти адрес) - не то что нам нужно
}

Map<BadUser, String> badMap = new HashMap<>();
BadUser user1 = new BadUser(1L, "John");
BadUser user2 = new BadUser(1L, "John"); // Тот же ID и имя

badMap.put(user1, "Data1");
badMap.put(user2, "Data2"); // Добавится как новый ключ!

System.out.println(badMap.size()); // 2 - НЕПРАВИЛЬНО!

// Правильная реализация
public class GoodUser {
    private Long id;
    private String name;
    
    public GoodUser(Long id, String name) {
        this.id = id;
        this.name = name;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        
        GoodUser user = (GoodUser) o;
        
        if (!id.equals(user.id)) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }
    
    @Override
    public int hashCode() {
        int result = id != null ? id.hashCode() : 0;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }
}

Map<GoodUser, String> goodMap = new HashMap<>();
GoodUser user1 = new GoodUser(1L, "John");
GoodUser user2 = new GoodUser(1L, "John"); // Тот же ID и имя

goodMap.put(user1, "Data1");
goodMap.put(user2, "Data2"); // Перезапишет Data1

System.out.println(goodMap.size()); // 1 - ПРАВИЛЬНО!

3. Использование @EqualsAndHashCode (Lombok)

import lombok.Data;
import lombok.EqualsAndHashCode;

@Data
@EqualsAndHashCode(of = {"id"})
public class Product {
    private Long id;
    private String name;
    private double price;
    
    // Lombok автоматически генерирует hashCode() и equals()
    // на основе поля id
}

Map<Product, String> products = new HashMap<>();
Product p1 = new Product(1L, "Phone", 999.99);
Product p2 = new Product(1L, "Tablet", 499.99); // Тот же ID

products.put(p1, "Available");
products.put(p2, "Available"); // Перезапишет

System.out.println(products.size()); // 1

4. Контракт hashCode() и equals()

public class CorrectHashCodeContract {
    private String email;
    private int age;
    
    public CorrectHashCodeContract(String email, int age) {
        this.email = email;
        this.age = age;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        
        CorrectHashCodeContract that = (CorrectHashCodeContract) o;
        
        // Используем только email для уникальности
        return email.equals(that.email);
    }
    
    @Override
    public int hashCode() {
        // ВАЖНО: используем только те же поля, что в equals()
        // Если в equals() сравниваем только email, то в hashCode() только email
        return email.hashCode();
    }
}

Map<CorrectHashCodeContract, String> map = new HashMap<>();
map.put(new CorrectHashCodeContract("john@mail.com", 25), "Data1");
map.put(new CorrectHashCodeContract("john@mail.com", 30), "Data2"); // Перезапишет
map.put(new CorrectHashCodeContract("jane@mail.com", 25), "Data3"); // Новый ключ

System.out.println(map.size()); // 2

5. Использование Immutable классов

// Неизменяемые объекты - идеальны для ключей
public final class ImmutableUser {
    private final Long id;
    private final String name;
    
    public ImmutableUser(Long id, String name) {
        this.id = id;
        this.name = name;
    }
    
    public Long getId() {
        return id;
    }
    
    public String getName() {
        return name;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof ImmutableUser)) return false;
        
        ImmutableUser user = (ImmutableUser) o;
        return Objects.equals(id, user.id) && 
               Objects.equals(name, user.name);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
}

// Objects.hash() - удобный способ
Map<ImmutableUser, String> map = new HashMap<>();
map.put(new ImmutableUser(1L, "John"), "Developer");
map.put(new ImmutableUser(2L, "Jane"), "Manager");

6. Records (Java 14+)

// Records автоматически переопределяют hashCode() и equals()
public record UserRecord(Long id, String email) {
    // hashCode() и equals() уже реализованы!
}

Map<UserRecord, String> map = new HashMap<>();
map.put(new UserRecord(1L, "john@mail.com"), "Data1");
map.put(new UserRecord(1L, "john@mail.com"), "Data2"); // Перезапишет

System.out.println(map.size()); // 1

7. LinkedHashMap - сохранение порядка

// LinkedHashMap сохраняет порядок вставки
Map<String, Integer> linkedMap = new LinkedHashMap<>();
linkedMap.put("apple", 10);
linkedMap.put("banana", 20);
linkedMap.put("cherry", 30);
linkedMap.put("apple", 15); // Перезапишет

// Итерация в порядке вставки
for (Map.Entry<String, Integer> entry : linkedMap.entrySet()) {
    System.out.println(entry); // apple=15, banana=20, cherry=30
}

8. TreeMap - сортировка ключей

// TreeMap требует, чтобы ключи были Comparable
Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("zebra", 1);
treeMap.put("apple", 2);
treeMap.put("mango", 3);

// Автоматически отсортирована
for (String key : treeMap.keySet()) {
    System.out.println(key); // apple, mango, zebra
}

// С кастомным компаратором
Map<String, Integer> customTree = new TreeMap<>(
    (a, b) -> b.compareTo(a) // Обратный порядок
);

9. Обработка коллизий

// HashMap автоматически обрабатывает коллизии через chaining
public class HashCollisionDemo {
    public static void main(String[] args) {
        // Два разных объекта с одинаковым hashCode()
        class BadKey {
            int value;
            BadKey(int value) { this.value = value; }
            
            @Override
            public int hashCode() {
                return 1; // Все объекты имеют одинаковый hashCode
            }
            
            @Override
            public boolean equals(Object o) {
                return this == o; // Только identity
            }
        }
        
        Map<BadKey, String> map = new HashMap<>();
        BadKey key1 = new BadKey(1);
        BadKey key2 = new BadKey(2);
        
        map.put(key1, "Value1");
        map.put(key2, "Value2");
        
        // Несмотря на коллизию, HashMap хранит оба значения
        System.out.println(map.size()); // 2
    }
}

10. Проверка уникальности перед добавлением

public class UniqueHashMap<K, V> extends HashMap<K, V> {
    @Override
    public V put(K key, V value) {
        if (this.containsKey(key)) {
            System.out.println("Key already exists: " + key);
            return get(key); // Не перезаписываем
        }
        return super.put(key, value);
    }
}

Map<String, String> uniqueMap = new UniqueHashMap<>();
uniqueMap.put("key1", "value1");
uniqueMap.put("key1", "value2"); // Не добавится

System.out.println(uniqueMap.get("key1")); // value1

Ключевые правила

1. Переопредели equals() и hashCode() для пользовательских классов
2. Используй одинаковые поля в equals() и hashCode()
3. Предпочитай Immutable объекты для ключей
4. Тестируй контракт hashCode()/equals() при разработке
5. Используй Records (Java 14+) для автоматической реализации
6. Документируй как определяется уникальность ключей

HashMap гарантирует уникальность ключей, если ты правильно реализуешь equals() и hashCode()!