Наследует ли HashMap интерфейс Collection

HashMap и интерфейс Collection: Иерархия и различия

Отличный вопрос о Java Collections Framework и иерархии типов! Ответ: НЕТ, HashMap НЕ реализует Collection, хотя это часто путают. Позвольме разобраться в этом детально.

Иерархия Collections Framework

Iterable
├── Collection (interface)
│   ├── List (interface)
│   │   ├── ArrayList
│   │   ├── LinkedList
│   │   └── Vector
│   ├── Set (interface)
│   │   ├── HashSet
│   │   ├── TreeSet
│   │   └── LinkedHashSet
│   └── Queue (interface)
│       ├── PriorityQueue
│       ├── Deque (interface)
│       └── LinkedList
│
Map (ОТДЕЛЬНО!) — НЕ наследует Collection
├── HashMap
├── TreeMap
├── LinkedHashMap
└── Hashtable

Почему HashMap НЕ Collection?

1. Семантика различается

// Collection — "контейнер элементов"
public interface Collection<E> extends Iterable<E> {
    int size();              // Количество элементов
    boolean isEmpty();       // Пусто ли?
    boolean contains(Object o);  // Содержит ли элемент?
    Iterator<E> iterator();  // Итератор по элементам
    // Методы работают с ЭЛЕМЕНТАМИ
}

// Map — "отображение ключ → значение"
public interface Map<K, V> {
    int size();              // Количество пар
    boolean isEmpty();       // Пусто ли?
    V get(Object key);       // Значение по ключу
    V put(K key, V value);   // Добавить пару
    Set<K> keySet();         // Множество ключей
    Collection<V> values();  // Коллекция значений
    Set<Map.Entry<K, V>> entrySet();  // Множество пар
    // Методы работают с ПАРАМИ
}

2. Разные операции

// Collection имеет:
Collection<String> list = new ArrayList<>();
list.add("John");           // add(E e)
list.remove("John");        // remove(Object o)
list.contains("John");      // contains(Object o)

// Map имеет:
Map<String, Integer> map = new HashMap<>();
map.put("John", 30);        // put(K key, V value)
map.remove("John");         // remove(Object key)
map.containsKey("John");    // containsKey(Object key)
map.get("John");            // get(Object key)

Как получить Collection из HashMap?

1. KeySet — Set ключей

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

// Получаем Set ключей (это Collection!)
Set<String> keys = map.keySet();  // [Alice, Bob, Charlie]
for (String key : keys) {
    System.out.println(key);
}

// Методы Collection доступны
boolean hasAlice = keys.contains("Alice");  // true
keys.size();  // 3

// ВАЖНО: keySet() связан с оригинальной Map!
keys.remove("Alice");
// "Alice" удалена и из Map!
map.containsKey("Alice");  // false

2. Values — Collection значений

// Получаем Collection значений
Collection<Integer> values = map.values();  // [25, 30, 35]
for (Integer age : values) {
    System.out.println(age);
}

// Методы Collection доступны
boolean has25 = values.contains(25);  // true
values.size();  // 3

// ВАЖНО: Collection может содержать дубликаты
Map<String, Integer> map2 = new HashMap<>();
map2.put("Alice", 25);
map2.put("Bob", 25);  // Такой же возраст

Collection<Integer> vals = map2.values();  // [25, 25]
vals.size();  // 2

3. EntrySet — Set пар Key-Value

// Самый эффективный способ итерировать Map
Set<Map.Entry<String, Integer>> entries = map.entrySet();

for (Map.Entry<String, Integer> entry : entries) {
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println(key + " -> " + value);
}

// Также можно изменять значения
for (Map.Entry<String, Integer> entry : entries) {
    entry.setValue(entry.getValue() + 1);  // Увеличиваем все значения
}

Сравнение типов

// HashMap
Map<String, Integer> map = new HashMap<>();
map.put("key1", 100);

System.out.println(map instanceof Map);         // true
System.out.println(map instanceof Collection);  // false

// ArrayList
Collection<String> list = new ArrayList<>();
list.add("item1");

System.out.println(list instanceof Collection);  // true
System.out.println(list instanceof Map);         // false

// HashSet
Collection<Integer> set = new HashSet<>();
set.add(1);

System.out.println(set instanceof Collection);   // true
System.out.println(set instanceof Map);          // false

HashMap реализует Iterable

Ключевое различие: HashMap НЕ итерируется как Collection

// ❌ НЕПРАВИЛЬНО: HashMap не Collection
Collection<HashMap<String, Integer>> wrong = new ArrayList<>();

// ❌ НЕПРАВИЛЬНО: Ожидаешь метод forEach(Consumer)?  
// HashMap имеет forEach, но НЕ как Collection
Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);

// Это работает (специальный метод Map)
map.forEach((key, value) -> System.out.println(key + " -> " + value));

// ✅ ПРАВИЛЬНО: Получить Collection из HashMap
Collection<Integer> values = map.values();
values.forEach(System.out::println);  // Здесь Collection

Практические примеры

Пример 1: Фильтрация данных из Map

Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 95);
scores.put("Bob", 87);
scores.put("Charlie", 92);
scores.put("David", 78);

// Получить все значения > 90
List<Integer> highScores = scores.values().stream()
    .filter(score -> score > 90)
    .collect(Collectors.toList());
// [95, 92]

// Получить все ключи с значением > 90
List<String> topStudents = scores.entrySet().stream()
    .filter(entry -> entry.getValue() > 90)
    .map(Map.Entry::getKey)
    .collect(Collectors.toList());
// [Alice, Charlie]

Пример 2: Преобразование Map в List

Map<String, Integer> map = new HashMap<>();
map.put("x", 10);
map.put("y", 20);
map.put("z", 30);

// Превратить в List<Entry>
List<Map.Entry<String, Integer>> list = 
    new ArrayList<>(map.entrySet());

// Сортировать по значениям
list.sort((e1, e2) -> e2.getValue() - e1.getValue());
// [(z, 30), (y, 20), (x, 10)]

// Получить List ключей
List<String> keys = new ArrayList<>(map.keySet());

// Получить List значений
List<Integer> values = new ArrayList<>(map.values());

Пример 3: Правильная типизация параметров

// ❌ НЕПРАВИЛЬНО: Принимает Collection
public void process(Collection<String> items) {
    for (String item : items) {
        System.out.println(item);
    }
}

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

// Ошибка: Map не совместима с Collection
process(map);  // ❌ Ошибка компилятора

// ✅ ПРАВИЛЬНО: Либо принимаем Map, либо его Collection
public void processCollection(Collection<String> items) {
    for (String item : items) {
        System.out.println(item);
    }
}

public void processMap(Map<String, Integer> map) {
    for (Map.Entry<String, Integer> entry : map.entrySet()) {
        System.out.println(entry.getKey() + " -> " + entry.getValue());
    }
}

// ✅ Использование
processCollection(map.values());      // Подаём values()
processCollection(map.keySet());      // Подаём keySet()
processMap(map);                      // Подаём саму Map

Таблица сравнения

Best Practices

// ✅ ПРАВИЛЬНО: Знать разницу
Map<String, String> userMap = new HashMap<>();

// Хотим получить Collection — используем values()
Collection<String> allValues = userMap.values();

// Хотим итерировать пары — используем entrySet()
for (Map.Entry<String, String> entry : userMap.entrySet()) {
    process(entry.getKey(), entry.getValue());
}

// Хотим только ключи — используем keySet()
Set<String> allKeys = userMap.keySet();

// ✅ ПРАВИЛЬНО: Использовать forEach для Map
Map<String, Integer> map = new HashMap<>();
map.forEach((key, value) -> {
    System.out.println(key + ": " + value);
});

// ✅ ПРАВИЛЬНО: Избегать entrySet во вложенных циклах
Map<String, List<Integer>> data = new HashMap<>();
for (Map.Entry<String, List<Integer>> entry : data.entrySet()) {
    for (Integer value : entry.getValue()) {
        // Обработка
    }
}

Выводы

1. HashMap НЕ реализует Collection
2. HashMap реализует Map — отдельный интерфейс
3. keySet() возвращает Set — это Collection
4. values() возвращает Collection — можно использовать
5. entrySet() самый эффективный для итерации
6. Различие важно для правильного использования API
7. Map требует special handling в коде работающем с Collections