Как работает Hashtable с null значениями?

Как работает Hashtable с null значениями

Hashtable — это устаревший класс коллекции в Java (предшественник HashMap), который был создан до введения Map интерфейса. Одно из ключевых различий между Hashtable и HashMap заключается в том, как они обрабатывают null значения. Это различие может привести к серьёзным ошибкам при неправильном понимании.

Hashtable НЕ ДОПУСКАЕТ null значения

В отличие от HashMap, Hashtable выбросит NullPointerException при попытке использовать null как ключ или значение:

Hashtable<String, String> table = new Hashtable<>();

// Попытка добавить null ключ
table.put(null, "value");  // NullPointerException!

// Попытка добавить null значение
table.put("key", null);    // NullPointerException!

Это произойдёт потому, что Hashtable вызывает hashCode() на ключе в методе put(), а у null нет метода hashCode().

Почему Hashtable не допускает null?

Установка null в Hashtable приводит к исключению в следующем коде внутри класса:

public synchronized V put(K key, V value) {
    // Проверка происходит в этом коде
    if (value == null) {
        throw new NullPointerException();  // Явная проверка на null значение
    }
    
    // Вызов hashCode() на ключе
    int hash = key.hashCode();  // NullPointerException если key == null
    // ...
}

Сравнение: Hashtable vs HashMap

// Hashtable - НЕЛЬЗЯ использовать null
Hashtable<String, Integer> hashtable = new Hashtable<>();
hashtable.put(null, 1);         // NullPointerException
hashtable.put("key", null);    // NullPointerException

// HashMap - МОЖНО использовать null
HashMap<String, Integer> hashMap = new HashMap<>();
hashMap.put(null, 1);           // OK, сохранит null как ключ
hashMap.put("key", null);      // OK, сохранит null как значение
hashMap.put(null, null);        // OK, оба null

// Получение из HashMap
Integer val = hashMap.get(null);  // 1
Integer val2 = hashMap.get("key"); // null

Практические последствия

Проблема 1: Преобразование типов

// Если переделать Hashtable на HashMap, код может сломаться
Map<String, String> map = new Hashtable<>();  // OK, работает
map = new HashMap<>();  // Вроде то же самое...

// Но вот эта строка может работать по-разному:
map.put("user", null);  // С HashMap - OK, с Hashtable - ошибка

Проблема 2: Логирование и обработка ошибок

public void saveUserData(Hashtable<String, Object> data) {
    // Если data содержит null значения
    for (Map.Entry<String, Object> entry : data.entrySet()) {
        String key = entry.getKey();
        Object value = entry.getValue();  // Никогда не будет null
        logger.info("{} = {}", key, value);
    }
}

Различия в поведении

// Получение значения из Hashtable
Hashtable<String, String> table = new Hashtable<>();
table.put("key1", "value1");

String result = table.get("key1");       // "value1"
String result2 = table.get("key2");      // null (ключа нет)
String result3 = table.get(null);        // NullPointerException!

// vs HashMap
HashMap<String, String> map = new HashMap<>();
map.put("key1", "value1");
map.put(null, "nullKey");

String result = map.get("key1");         // "value1"
String result2 = map.get("key2");        // null (ключа нет)
String result3 = map.get(null);          // "nullKey" (OK)

Синхронизация - ещё одно отличие

Кроме работы с null, Hashtable также синхронизирован (thread-safe):

// Hashtable - все методы synchronized
public synchronized V put(K key, V value) { ... }
public synchronized V get(Object key) { ... }

// HashMap - не синхронизирован
public V put(K key, V value) { ... }  // БЕЗ synchronized
public V get(Object key) { ... }

// Для потокобезопасности лучше использовать ConcurrentHashMap
ConcurrentHashMap<String, String> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put("key", "value");  // Thread-safe
// Но ConcurrentHashMap ТОЖЕ НЕ допускает null в ключах и значениях!
concurrentMap.put(null, "value");   // NullPointerException

Когда вы встретите эту ошибку

public class UserCache {
    private Hashtable<String, User> cache = new Hashtable<>();
    
    public void cacheUser(String id, User user) {
        // Если user == null, будет исключение
        cache.put(id, user);  // NullPointerException при user == null
    }
    
    public User getUser(String id) {
        // Здесь всё OK - возвращает null если нет
        return cache.get(id);
    }
}

// Использование
UserCache cache = new UserCache();
User user = findUser("123");  // Может вернуть null
cache.cacheUser("123", user);  // Крах, если user == null

Как правильно обработать

// Вариант 1: Проверка перед добавлением
if (user != null) {
    cache.put(id, user);
}

// Вариант 2: Использовать HashMap вместо Hashtable
Map<String, User> cache = new HashMap<>();
if (user != null) {
    cache.put(id, user);
} else {
    cache.put(id, new User("unknown"));  // Подставить значение по умолчанию
}

// Вариант 3: Использовать Optional
Optional<User> optionalUser = findUser("123");
if (optionalUser.isPresent()) {
    cache.put("123", optionalUser.get());
}

// Вариант 4: ConcurrentHashMap для потокобезопасности без null
ConcurrentHashMap<String, User> cache = new ConcurrentHashMap<>();
User user = findUser("123");
if (user != null) {
    cache.put(id, user);
}

Почему так сделано?

Hashtable был создан в Java 1.0 (1996) когда требования были другие:

1. Null как сигнал об ошибке — так было принято в то время
2. Производительность — проверка null быстрее, чем обработка null hashCode
3. Безопасность типов — null в ключах может привести к baggy логике

Это решение немного устарело, но сохранено для обратной совместимости.

Резюме

• Hashtable: НЕ допускает null ключи и null значения, выбросит NullPointerException
• HashMap: допускает один null ключ и множество null значений
• ConcurrentHashMap: потокобезопасен, но также НЕ допускает null, как Hashtable
• Лучшие практики: использовать HashMap для новых проектов или Collections.synchronizedMap() для синхронизации; проверять на null перед вставкой в Hashtable