Почему Map не является коллекцией?

# Почему Map не является Collection

Это часто задаваемый вопрос, и ответ лежит в семантике и проектировании Collections Framework. Хотя Map и HashMap находятся в одном пакете java.util, Map не наследует интерфейс Collection.

Причины дизайна

1. Различная семантика данных

Collection хранит отдельные элементы:

Collection<String> names = new ArrayList<>();
names.add("John");   // один элемент
names.add("Alice");  // один элемент

Map хранит пары ключ-значение:

Map<String, Integer> ages = new HashMap<>();
ages.put("John", 30);   // пара
ages.put("Alice", 25);  // пара

Это принципиально разные структуры данных:

• Collection: элементы
• Map: соответствия между ключами и значениями

2. Несовместимость методов

Методы Collection не имеют смысла для Map:

public interface Collection<E> extends Iterable<E> {
    boolean add(E e);           // что добавлять? ключ или значение?
    boolean remove(Object o);   // удалять по чему?
    boolean contains(Object o); // проверять что?
}

Для Map это неоднозначно:

Map<String, Integer> map = new HashMap<>();
map.put("John", 30);

// Если бы Map был Collection:
map.add(???);           // что это должно быть? Map.Entry? Ключ? Значение?
map.remove("John");     // удалять ключ или по значению?
map.contains(30);       // проверяем ключ или значение?

3. Правило контракта Iterator

Collection гарантирует итерацию по элементам. Минимум нужно определить: что такое "элемент" в Map?

// Если итерировать по ключам:
for(String key : map.keySet()) { }

// Если по значениям:
for(Integer value : map.values()) { }

// Если по парам:
for(Map.Entry<String, Integer> entry : map.entrySet()) { }

Коллекция не может одновременно быть тремя разными вещами.

4. Разные операции добавления

// Для Collection
List<String> list = new ArrayList<>();
list.add("John");  // один параметр

// Для Map
Map<String, Integer> map = new HashMap<>();
map.put("John", 30);  // два параметра (ключ и значение)

Добавление в Map требует двух значений, в Collection — одного.

5. Дублирование ключей vs элементов

// Collection не позволяет дубликаты (для Set)
Set<String> set = new HashSet<>();
set.add("John");
set.add("John"); // не добавится
System.out.println(set.size()); // 1

// Map позволяет дубликаты значений, но не ключей
Map<String, Integer> map = new HashMap<>();
map.put("John", 30);
map.put("John", 35);  // перезапишет значение
map.put("Alice", 30); // другой ключ, одинаковое значение OK
System.out.println(map.size()); // 2

Решение: три представления Map

Vместо наследования Collection, Map предоставляет методы для получения представлений (views), которые ARE коллекции:

Map<String, Integer> map = new HashMap<>();
map.put("John", 30);
map.put("Alice", 25);
map.put("Bob", 35);

// 1. Представление ключей — это Set
Set<String> keys = map.keySet();
keys.forEach(System.out::println); // John, Alice, Bob
keys.contains("John");    // true — это Collection операция
keys.remove("Alice");     // удаляет из Map!

// 2. Представление значений — это Collection
Collection<Integer> values = map.values();
values.forEach(System.out::println); // 30, 25, 35
values.contains(30);  // true
values.remove(30);    // удаляет из Map

// 3. Представление пар — это Set
Set<Map.Entry<String, Integer>> entries = map.entrySet();
for(Map.Entry<String, Integer> entry : entries) {
    String key = entry.getKey();
    Integer value = entry.getValue();
    entry.setValue(value + 1); // изменить значение
}

Иерархия в Java Collections Framework

Iterable<E>
    ├── Collection<E>
    │   ├── List<E>      (ArrayList, LinkedList)
    │   ├── Set<E>       (HashSet, TreeSet)
    │   └── Queue<E>     (LinkedList, PriorityQueue)
    └── Map<K,V>         (HashMap, TreeMap)  ← ОТДЕЛЬНАЯ ветвь

Map находится на одном уровне с Collection, но это ОТДЕЛЬНЫЙ интерфейс.

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

// ✅ Правильно: работаем с представлениями
Map<String, Integer> map = new HashMap<>();
map.put("John", 30);

// Работаем с ключами как с Set
Set<String> keys = map.keySet();
for(String key : keys) {
    System.out.println(key);
}

// ✅ Правильно: работаем с записями
for(Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + " -> " + entry.getValue());
}

// ❌ Неправильно: если бы Map был Collection
// Collection<?> collection = map; // compilation error, как и должно быть

Итоговый вывод

1. Семантика — Collection и Map представляют разные концепции
2. Методы — операции Collection не применимы к Map однозначно
3. Дизайн — Map предоставляет представления (views) как Collection
4. Гибкость — три представления (ключи, значения, записи) покрывают все случаи

Это хороший пример грамотного объектно-ориентированного дизайна, где иерархия типов отражает семантику данных.