Когда может произойти потеря значения при иммутабельном ключе в HashMap?

Потеря значения при иммутабельном ключе в HashMap

Это коварный вопрос собеседования, который тестирует глубокое понимание HashMap, хеширования и иммутабельности. На первый взгляд кажется, что с иммутабельным ключом ничего не может пойти не так. Но это не совсем верно.

Основное правило: истинная иммутабельность

Иммутабельный (неизменяемый) ключ — это объект, чьё состояние не может измениться после создания.

// ✅ Истинно иммутабельный ключ
public final class ImmutableKey {
    private final String value;
    private final int id;
    
    public ImmutableKey(String value, int id) {
        this.value = value;
        this.id = id;
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(value, id);
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof ImmutableKey)) return false;
        ImmutableKey other = (ImmutableKey) obj;
        return Objects.equals(value, other.value) && id == other.id;
    }
}

Сценарий 1: Видимость поля изменения (Race Condition)

Потеря значения может произойти в многопоточной среде, даже если объект кажется иммутабельным на уровне API.

// ❌ Потенциально опасно в многопоточной среде
public class MutableKey {
    private String value;  // ❌ НЕ final
    
    public MutableKey(String value) {
        this.value = value;
    }
    
    @Override
    public int hashCode() {
        return value.hashCode();
    }
    
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof MutableKey)) return false;
        return value.equals(((MutableKey) obj).value);
    }
}

// Проблема в многопоточной среде
public class HashMapRaceCondition {
    public static void main(String[] args) throws InterruptedException {
        HashMap<MutableKey, String> map = new HashMap<>();
        MutableKey key = new MutableKey("initial");
        
        map.put(key, "value1");
        
        // Поток 1: пытается найти значение
        Thread t1 = new Thread(() -> {
            String result = map.get(key);
            System.out.println("Found: " + result);
        });
        
        // Поток 2: изменяет ключ (через рефлексию)
        Thread t2 = new Thread(() -> {
            try {
                Field field = MutableKey.class.getDeclaredField("value");
                field.setAccessible(true);
                field.set(key, "changed");  // ❌ Меняем значение
                System.out.println("Key changed to: changed");
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        
        // Результат может быть "null" вместо "value1"
        System.out.println("Final value: " + map.get(key));
    }
}

Сценарий 2: Изменение через рефлексию

Даже «иммутабельный» класс можно модифицировать через рефлексию:

public final class FinalKey {
    private final String value;  // ✅ final
    
    public FinalKey(String value) {
        this.value = value;
    }
    
    @Override
    public int hashCode() {
        return value.hashCode();
    }
    
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof FinalKey)) return false;
        return value.equals(((FinalKey) obj).value);
    }
}

public class ReflectionHack {
    public static void main(String[] args) throws Exception {
        HashMap<FinalKey, String> map = new HashMap<>();
        FinalKey key = new FinalKey("original");
        
        map.put(key, "important_value");
        System.out.println("Initial: " + map.get(key));  // important_value
        
        // ❌ Атакуем через рефлексию!
        Field field = FinalKey.class.getDeclaredField("value");
        field.setAccessible(true);
        field.set(key, "hacked");
        
        System.out.println("After hack: " + map.get(key));  // null!
        System.out.println("All entries: " + map);  // Значение потеряно!
    }
}

Результат:

Initial: important_value
After hack: null
All entries: {}

Почему происходит потеря значения?

Проблема с хешированием:

Шаг 1: Вставка ключа "original"
- hashCode("original") = 1234567
- Значение сохранено в bucket[1234567]

Шаг 2: Изменение ключа на "hacked"
- hashCode("hacked") = 7654321
- Попытка поиска ищет в bucket[7654321]
- Но значение всё ещё в bucket[1234567]
- Результат: null (потеря значения)

Сценарий 3: Изменение через сеттеры (не final класс)

// ❌ Опасно! Класс не final
public class BadKey {
    private final String value;
    private int state;  // Может меняться
    
    public BadKey(String value) {
        this.value = value;
        this.state = 0;
    }
    
    public void setState(int state) {  // ❌ Мутирующий метод
        this.state = state;
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(value, state);  // ❌ Зависит от state
    }
    
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof BadKey)) return false;
        BadKey other = (BadKey) obj;
        return value.equals(other.value) && state == other.state;
    }
}

public class MutableStateExample {
    public static void main(String[] args) {
        HashMap<BadKey, String> map = new HashMap<>();
        BadKey key = new BadKey("key");
        
        map.put(key, "value");  // hashCode = 10
        System.out.println("Found: " + map.get(key));  // value
        
        key.setState(1);  // Изменяем состояние
        // hashCode теперь = 11
        
        System.out.println("Found after change: " + map.get(key));  // null!
    }
}

Сценарий 4: Подклассы и переопределение методов

public class Key {
    protected int value;  // protected вместо private final
    
    public Key(int value) {
        this.value = value;
    }
    
    @Override
    public int hashCode() {
        return Integer.hashCode(value);
    }
    
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Key)) return false;
        return value == ((Key) obj).value;
    }
}

// ❌ Подкласс может нарушить контракт
public class MutableSubkey extends Key {
    public void setValue(int newValue) {  // ❌ Мутирующий метод
        this.value = newValue;
    }
}

public class SubclassExample {
    public static void main(String[] args) {
        HashMap<Key, String> map = new HashMap<>();
        MutableSubkey key = new MutableSubkey(10);
        
        map.put(key, "data");
        System.out.println("Before: " + map.get(key));  // data
        
        key.setValue(20);  // Меняем значение
        System.out.println("After: " + map.get(key));   // null
    }
}

Как правильно сделать истинно иммутабельный ключ

// ✅ ПРАВИЛЬНО!
public final class ProperKey {
    // 1. Класс final (нельзя наследоваться)
    // 2. Все поля final (не могут меняться)
    private final String name;
    private final int id;
    
    public ProperKey(String name, int id) {
        this.name = Objects.requireNonNull(name);
        this.id = id;
    }
    
    // 3. hashCode/equals зависят только от иммутабельных полей
    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof ProperKey)) return false;
        ProperKey other = (ProperKey) obj;
        return Objects.equals(name, other.name) && id == other.id;
    }
    
    // 4. Нет сеттеров, никаких мутирующих методов
    // 5. Если содержит объекты — они тоже должны быть иммутабельны
    
    @Override
    public String toString() {
        return "ProperKey{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
}

Проверка с тестом

public class KeyImmutabilityTest {
    @Test
    public void testKeyImmutability() {
        HashMap<ProperKey, String> map = new HashMap<>();
        ProperKey key1 = new ProperKey("user", 1);
        ProperKey key2 = new ProperKey("user", 1);
        
        map.put(key1, "value1");
        
        // Одинаковые ключи указывают на одно значение
        assertEquals("value1", map.get(key2));
        
        // Попытка создать новый ключ с тем же значением
        ProperKey key3 = new ProperKey("user", 1);
        assertEquals("value1", map.get(key3));
        
        // hashCode совпадает
        assertEquals(key1.hashCode(), key2.hashCode());
        assertEquals(key2.hashCode(), key3.hashCode());
    }
}

Заключение

Потеря значения при иммутабельном ключе может произойти:

1. Через рефлексию — можно изменить даже final поля
2. Многопоточность — race conditions без volatile/synchronized
3. Изменяемые подклассы — наследование нарушает контракт
4. Изменяемые поля в класс-ключе — hashCode меняется во времени
5. Содержащиеся изменяемые объекты — если String может измениться

Правило безопасности для HashMap:

public final class MyKey {
    // final класс + final поля
    // = true иммутабельность
}

Ответ эксперта: Даже кажущийся иммутабельный ключ может потеряться, если он может быть изменён через рефлексию, наследование или содержит изменяемые поля. Используй final класс с final полями для полной гарантии.