Что произойдет если положить ключ null в TreeMap?

Что произойдет при попытке вставить null в качестве ключа в TreeMap

Это важный вопрос о различиях между HashMap и TreeMap. Ответ: будет выброшено исключение NullPointerException.

TreeMap требует сравнения ключей

TreeMap - это реализация отсортированного map'а, которая основана на красно-черном дереве. Для поддержания порядка ей нужно сравнивать ключи.

public class TreeMapNullExample {
    public static void main(String[] args) {
        TreeMap<String, Integer> map = new TreeMap<>();
        
        try {
            map.put(null, 1);  // NullPointerException!
        } catch (NullPointerException e) {
            System.out.println("Ошибка: " + e.getMessage());
            // java.lang.NullPointerException
        }
    }
}

Почему происходит исключение

Когда вы пытаетесь вставить элемент в TreeMap, он должен найти правильную позицию в дереве. Это требует сравнения нового ключа с существующими ключами.

public class TreeMapComparison {
    public static void main(String[] args) {
        TreeMap<String, Integer> map = new TreeMap<>();
        map.put("b", 2);
        map.put("a", 1);  // Сравнивает с "b"
        map.put("c", 3);  // Сравнивает с "b" и "a"
        
        System.out.println(map);  // {a=1, b=2, c=3} - отсортировано
        
        // Теперь попытаемся вставить null
        try {
            map.put(null, 0);
            // Необходимо сравнить null с "b" (или другим ключом)
            // Это вызывает: null.compareTo("b") - NullPointerException
        } catch (NullPointerException e) {
            System.out.println("Не можем сравнить null с существующими ключами");
        }
    }
}

Разница между HashMap и TreeMap

Можно ясно увидеть разницу в обращении с null.

// HashMap ПОЗВОЛЯЕТ null ключи
HashMap<String, Integer> hashMap = new HashMap<>();
hashMap.put(null, 1);  // OK - HashMap хранит null ключи
hashMap.put(null, 2);  // Перезаписывает значение
System.out.println(hashMap.get(null));  // 2

// Но только ОДИН null ключ (т.к. это один и тот же ключ)
System.out.println(hashMap.size());  // 1

// TreeMap НЕ ПОЗВОЛЯЕТ null ключи
TreeMap<String, Integer> treeMap = new TreeMap<>();
try {
    treeMap.put(null, 1);  // NullPointerException!
} catch (NullPointerException e) {
    System.out.println("TreeMap не поддерживает null ключи");
}

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

Важный момент: если TreeMap пуст, первая вставка null может не вызвать исключение сразу!

public class TreeMapNullFirstInsert {
    public static void main(String[] args) {
        TreeMap<String, Integer> map = new TreeMap<>();
        
        try {
            // Пустой map - ничего не нужно сравнивать!
            map.put(null, 1);
            System.out.println("Первый null успешно вставлен");
            System.out.println("Map: " + map);
            System.out.println("Size: " + map.size());
            
            // Теперь попытаемся вставить следующий элемент
            map.put("a", 2);  // Здесь произойдет NullPointerException!
        } catch (NullPointerException e) {
            System.out.println("NullPointerException при сравнении");
            e.printStackTrace();
        }
    }
}
// Output:
// Первый null успешно вставлен
// NullPointerException при сравнении

Это происходит потому что:

1. При вставке в пустой map - элемент просто становится корневым узлом дерева
2. При вставке следующего элемента - нужно сравнить с корневым null
3. null.compareTo(...) - это невозможно!

Правильное решение: использовать Comparator

Если вам действительно нужно работать с null ключами, используйте custom Comparator.

public class TreeMapWithNullComparator {
    public static void main(String[] args) {
        // Comparator, который обрабатывает null значения
        Comparator<String> nullSafeComparator = new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                if (a == null && b == null) return 0;     // оба null
                if (a == null) return -1;                  // null идет в начало
                if (b == null) return 1;                   // null идет в конец
                return a.compareTo(b);                     // обычное сравнение
            }
        };
        
        TreeMap<String, Integer> map = new TreeMap<>(nullSafeComparator);
        
        map.put(null, 0);   // OK!
        map.put("b", 2);    // OK!
        map.put("a", 1);    // OK!
        map.put("c", 3);    // OK!
        
        System.out.println(map);  // {null=0, a=1, b=2, c=3}
    }
}

Альтернатива с Lambda (Java 8+)

public class TreeMapWithLambda {
    public static void main(String[] args) {
        TreeMap<String, Integer> map = new TreeMap<>((a, b) -> {
            if (a == null && b == null) return 0;
            if (a == null) return -1;
            if (b == null) return 1;
            return a.compareTo(b);
        });
        
        map.put(null, 0);
        map.put("b", 2);
        map.put("a", 1);
        
        System.out.println(map);  // {null=0, a=1, b=2}
    }
}

Рекомендация: использовать LinkedHashMap

Если вам нужна гибкость HashMap но с сохранением порядка вставки, используйте LinkedHashMap.

public class LinkedHashMapExample {
    public static void main(String[] args) {
        // LinkedHashMap поддерживает null ключи и сохраняет порядок
        LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
        
        map.put(null, 0);      // OK - null ключ
        map.put("b", 2);       // OK
        map.put("a", 1);       // OK
        map.put("c", 3);       // OK
        
        System.out.println(map);  // {null=0, b=2, a=1, c=3}
        // Сохраняет порядок вставки, не сортирует
    }
}

Сравнение Map реализаций с null

public class MapNullComparison {
    public static void main(String[] args) {
        // HashMap - поддерживает null ключи
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put(null, 0);
        System.out.println("HashMap с null: " + hashMap);  // OK
        
        // LinkedHashMap - поддерживает null ключи, сохраняет порядок
        LinkedHashMap<String, Integer> linkedMap = new LinkedHashMap<>();
        linkedMap.put(null, 0);
        System.out.println("LinkedHashMap с null: " + linkedMap);  // OK
        
        // TreeMap - НЕ поддерживает null ключи
        TreeMap<String, Integer> treeMap = new TreeMap<>();
        try {
            treeMap.put(null, 0);
        } catch (NullPointerException e) {
            System.out.println("TreeMap с null: NullPointerException");
        }
        
        // ConcurrentHashMap - НЕ поддерживает null ключи
        ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
        try {
            concurrentMap.put(null, 0);
        } catch (NullPointerException e) {
            System.out.println("ConcurrentHashMap с null: NullPointerException");
        }
    }
}

Резюме

При попытке вставить null в TreeMap:

1. Если map пуст - null может быть вставлен как корневой элемент
2. При добавлении следующего элемента - будет выброшено NullPointerException
3. Причина - TreeMap нужно сравнивать ключи для поддержания сортировки
4. Решение:
   • Используйте null-safe Comparator
   • Или используйте HashMap/LinkedHashMap если нужны null ключи
   • Или не используйте null ключи вообще

Это важное различие между HashMap (позволяет null) и TreeMap (не позволяет).