Для чего нужен IdentityHashMap?

# Для чего нужен IdentityHashMap?

Основное назначение

IdentityHashMap — это специализированная реализация Map, которая использует идентичность объектов (ссылка на объект в памяти) вместо метода equals() для сравнения ключей.

Обычный HashMap использует hashCode() и equals(), а IdentityHashMap использует System.identityHashCode() и оператор ==.

HashMap vs IdentityHashMap

// HashMap - сравнивает значения через equals()
Map<String, String> hashMap = new HashMap<>();
String key1 = new String("hello");
String key2 = new String("hello");

hashMap.put(key1, "value1");
hashMap.put(key2, "value2");

System.out.println(hashMap.size());  // 1
// Потому что key1.equals(key2) == true
// Второе значение перезаписало первое

// IdentityHashMap - сравнивает ссылки через ==
Map<String, String> identityMap = new IdentityHashMap<>();
identityMap.put(key1, "value1");
identityMap.put(key2, "value2");

System.out.println(identityMap.size());  // 2
// Потому что key1 != key2 (разные объекты в памяти)

Как работает сравнение ключей

String s1 = new String("test");
String s2 = new String("test");
String s3 = s1;

Map<String, Integer> hashMap = new HashMap<>();
hashMap.put(s1, 1);
hashMap.put(s2, 2);
hashMap.put(s3, 3);

System.out.println(hashMap.size());  // 1
// s1, s2, s3 - при equals() возвращают true
// Все три перезаписывают друг друга

Map<String, Integer> identityMap = new IdentityHashMap<>();
identityMap.put(s1, 1);
identityMap.put(s2, 2);
identityMap.put(s3, 3);

System.out.println(identityMap.size());  // 2
// s1 и s3 - одна и та же ссылка (один элемент)
// s2 - другая ссылка (второй элемент)

Внутренний механизм

public class IdentityHashMap<K, V> extends AbstractMap<K, V> {
    // Не использует hashCode()
    // Использует System.identityHashCode(key)
    
    private static int hash(Object key) {
        return System.identityHashCode(key);  // Hash по адресу объекта
    }
    
    private static boolean eq(Object o1, Object o2) {
        return o1 == o2;  // Сравнение через ==, не equals()
    }
    
    // В get() и put():
    public V put(K key, V value) {
        int hash = hash(key);  // identityHashCode
        
        for (int i = 0; i < table.length; i += 2) {
            Object k = table[i];
            if (eq(k, key)) {  // Сравнение через ==
                // Ключ найден
                return table[i + 1];
            }
        }
        // Добавляем новый элемент
        return null;
    }
}

Практические примеры использования

1. Отслеживание объектов по ссылкам

class CycleDetector {
    public boolean hasCycle(Node root) {
        // Отслеживаем посещённые объекты (не по значению, а по ссылке!)
        Map<Node, Boolean> visited = new IdentityHashMap<>();
        
        return dfs(root, visited);
    }
    
    private boolean dfs(Node node, Map<Node, Boolean> visited) {
        if (visited.containsKey(node)) {
            return true;  // Цикл найден
        }
        
        visited.put(node, true);
        
        for (Node next : node.getChildren()) {
            if (dfs(next, visited)) {
                return true;
            }
        }
        
        return false;
    }
}

2. Обнаружение дублирования объектов

public class ObjectDeduplicator {
    public List<User> deduplicate(List<User> users) {
        // HashMap опирается на equals() и hashCode()
        // Два разных объекта User с одинаковыми данными будут считаться разными
        Map<User, Boolean> seen = new IdentityHashMap<>();
        
        List<User> result = new ArrayList<>();
        for (User user : users) {
            if (!seen.containsKey(user)) {
                seen.put(user, true);
                result.add(user);
            }
        }
        return result;
    }
}

// Использование:
User u1 = new User("John");
User u2 = new User("John");  // Разные объекты, но equals() вернёт true

List<User> users = Arrays.asList(u1, u2);
List<User> dedup = new ObjectDeduplicator().deduplicate(users);

// С HashMap: размер 1 (потому что equals())
// С IdentityHashMap: размер 2 (потому что разные объекты)

3. Граф объектов (для анализа памяти)

public class HeapAnalyzer {
    public void analyzeReferences() {
        // Отслеживаем все объекты, на которые есть ссылки
        Map<Object, Set<Object>> graph = new IdentityHashMap<>();
        
        Object root = new Object();
        analyzeObject(root, graph);
        
        for (Map.Entry<Object, Set<Object>> entry : graph.entrySet()) {
            System.out.println(entry.getKey().getClass().getSimpleName() + 
                             " ссылается на " + entry.getValue().size() + " объектов");
        }
    }
    
    private void analyzeObject(Object obj, Map<Object, Set<Object>> graph) {
        if (graph.containsKey(obj)) {
            return;  // Уже обработан
        }
        
        Set<Object> references = new IdentityHashSet<>();
        // Анализируем поля объекта
        graph.put(obj, references);
    }
}

4. Кэширование с привязкой к конкретному объекту

public class ObjectProxyCache {
    // Кэш для прокси объектов
    private Map<Object, Object> proxies = new IdentityHashMap<>();
    
    public Object getProxy(Object original) {
        if (!proxies.containsKey(original)) {
            // Создаём новый прокси
            Object proxy = Proxy.newProxyInstance(
                original.getClass().getClassLoader(),
                original.getClass().getInterfaces(),
                new InvocationHandler() {
                    public Object invoke(Object obj, Method method, Object[] args) {
                        // ...
                        return method.invoke(original, args);
                    }
                }
            );
            proxies.put(original, proxy);
        }
        return proxies.get(original);
    }
}

// Использование:
User user1 = new User("John");
User user2 = new User("John");  // Разные объекты

ObjectProxyCache cache = new ObjectProxyCache();
Object proxy1 = cache.getProxy(user1);
Object proxy2 = cache.getProxy(user2);

// proxy1 != proxy2, потому что это разные оригинальные объекты

5. Отслеживание синглтонов

public class SingletonRegistry {
    private Map<Class<?>, Object> singletons = new IdentityHashMap<>();
    
    public <T> void register(Class<T> clazz, T instance) {
        singletons.put(clazz, instance);
    }
    
    public <T> T get(Class<T> clazz) {
        return (T) singletons.get(clazz);
    }
}

Когда использовать IdentityHashMap

✓ ИСПОЛЬЗУЙ IdentityHashMap когда:
  1. Нужно различать объекты по ссылке, не по значению
  2. Отслеживание циклических ссылок
  3. Обнаружение дублирования объектов в памяти
  4. Кэширование, привязанное к конкретному объекту
  5. Анализ графа объектов
  6. Нужна максимальная производительность (System.identityHashCode() быстрее)

✗ НЕ используй IdentityHashMap когда:
  1. Нужно сравнивать объекты по значению (equals())
  2. Работаешь с String, Integer, другими объектами с переопределённым equals()
  3. Можно использовать обычный HashMap

Важные моменты

// 1. IdentityHashMap не использует equals()
String s1 = "hello";
String s2 = new String("hello");

Map<String, Integer> map = new IdentityHashMap<>();
map.put(s1, 1);
map.put(s2, 2);

System.out.println(map.get(s1));  // 1
System.out.println(map.get(s2));  // 2
System.out.println(map.size());   // 2

// 2. Для null - работает нормально
map.put(null, 999);
System.out.println(map.get(null));  // 999

// 3. Быстрее HashMap на некоторых операциях
// Потому что не нужно вызывать equals()

Итог

IdentityHashMap — специализированный инструмент для случаев, когда нужно различать объекты по ссылке в памяти, а не по значению. Он полезен при отслеживании циклических ссылок, анализе графов объектов и кэшировании с привязкой к конкретному экземпляру. В 99% случаев используется обычный HashMap, но IdentityHashMap критичен для определённых алгоритмов и задач.