Коллекции в Java: Collection Framework и иерархия коллекций

Попробуйте написать Collection<String> names = new HashMap<String, String>(); — компилятор ответит incompatible types: HashMap<String,String> cannot be converted to Collection<String>. HashMap входит в Collection Framework, но интерфейс Collection не реализует. Чтобы такие сюрпризы не случались, сначала нужно увидеть иерархию коллекций целиком.

Collection Framework (Java Collections Framework) — это набор интерфейсов, реализаций и алгоритмов из пакета java.util для хранения и обработки групп объектов: списков, множеств, очередей и отображений «ключ–значение». В отличие от массива, размер коллекции меняется динамически, а готовые методы позволяют искать, сортировать и фильтровать элементы без ручного кода. Коллекции появились в J2SE 1.2 (1998), обобщённые типы в них — в Java 5.

Из чего состоит Collection Framework

Collection Framework в Java состоит из трёх частей: интерфейсов, которые описывают поведение коллекции (список, множество, очередь, отображение), реализаций — готовых классов вроде ArrayList и HashMap, и алгоритмов — статических методов для сортировки, поиска и перемешивания.

Переменную принято объявлять типом интерфейса, а реализацию указывать только в new: List<String> names = new ArrayList<>();. Тогда реализацию можно заменить одной строкой, не трогая остальной код. Сами структуры данных (список, стек, очередь, множество) без привязки к Java описаны в уроке Структуры данных в Java.

Иерархия коллекций Java

Иерархия коллекций Java состоит из двух независимых веток. Первая начинается с интерфейса Collection (он расширяет Iterable) и делится на List, Set и Queue. Вторая — интерфейс Map для пар «ключ–значение»: он входит в Collection Framework, но Collection не наследует.

Та же иерархия в текстовом виде (стрелка → означает «расширяет / реализует», после тире указаны основные классы):

Iterable<T>
└── Collection<E>
    ├── List<E>            — ArrayList, LinkedList, Vector → Stack
    ├── Set<E>             — HashSet → LinkedHashSet
    │   └── SortedSet<E> → NavigableSet<E>   — TreeSet
    └── Queue<E>           — PriorityQueue
        └── Deque<E>       — ArrayDeque, LinkedList

Map<K,V>                   — HashMap → LinkedHashMap, Hashtable
└── SortedMap<K,V> → NavigableMap<K,V>  — TreeMap

Обратите внимание: LinkedList встречается в двух ветках — он реализует и List, и Deque. Vector, Stack и Hashtable — классы из Java 1.0, встроенные в иерархию задним числом; в новом коде их не используют (урок Legacy Classes).

Основные интерфейсы коллекций

Основных интерфейсов коллекций шесть: List (упорядоченный список с индексами), Set (множество без дубликатов), SortedSet/NavigableSet (отсортированное множество), Queue (очередь), Deque (двусторонняя очередь и стек) и Map (пары «ключ–значение»). Различаются они тем, допускают ли дубликаты и в каком порядке отдают элементы.

Как сравниваются элементы в отсортированных коллекциях, объясняет урок Comparable и Comparator, а как их перебирать — урок Iterator.

Какую реализацию выбрать

Реализацию выбирают по трём вопросам: нужен ли доступ по индексу, важен ли порядок элементов и нужна ли сортировка. В большинстве задач хватает ArrayList, HashSet, HashMap и ArrayDeque. Остальные классы нужны, когда требуется особый порядок или быстрые вставки на концах списка.

Упорядоченные и отсортированные коллекции

Столбец «Порядок» в таблице описывает два разных свойства. Упорядоченная (ordered) коллекция перебирает элементы в предсказуемом порядке, который не зависит от их значений: по индексу или по порядку вставки. Отсортированная (sorted) коллекция сама расставляет элементы по их значениям — в естественном порядке (Comparable) или по правилу Comparator.

Set<String> linked = new LinkedHashSet<>(List.of("pear", "apple", "fig"));
Set<String> sorted = new TreeSet<>(List.of("pear", "apple", "fig"));
System.out.println(linked); // [pear, apple, fig] — порядок вставки
System.out.println(sorted); // [apple, fig, pear] — по алфавиту

Если важно, в каком порядке элементы вернутся при обходе, «упорядоченной» коллекции может оказаться недостаточно: LinkedHashSet сохранит порядок добавления, но не отсортирует данные. PriorityQueue — особый случай: poll() всегда отдаёт наименьший элемент, но итератор обходит кучу без сортировки.

Почему LinkedList проигрывает ArrayList при доступе по индексу, разобрано в уроке LinkedList, а зачем элементам HashSet и ключам HashMap методы equals() и hashCode() — в уроке Set и HashSet.

Обобщённые коллекции

Все интерфейсы и классы Collection Framework обобщённые (с Java 5): тип элементов указывают в угловых скобках, например List<String>. Компилятор не даст положить в такую коллекцию объект другого типа, а при чтении не потребуется приведение типа. Коллекция без параметра (raw type) компилируется только с предупреждением и ломается уже во время выполнения.

import java.util.ArrayList;
import java.util.List;

public class RawListExample {
    public static void main(String[] args) {
        List raw = new ArrayList();      // raw type: компилятор выдаст только warning
        raw.add("Java");
        raw.add(42);                     // ошибки нет — тип элементов не проверяется

        for (Object item : raw) {
            String s = (String) item;    // на втором элементе — исключение
            System.out.println(s.toUpperCase());
        }
    }
}

Вывод:

JAVA
Exception in thread "main" java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')
	at RawListExample.main(RawListExample.java:11)

С объявлением List<String> list = new ArrayList<>(); строка list.add(42) не скомпилируется — ошибка найдена до запуска. Примитивы (int, double) в коллекции не кладут: используется класс-обёртка (List<Integer>) и автоупаковка. Wildcard <? extends T> и <? super T> в параметрах методов объясняет урок принцип PECS.

Неизменяемые коллекции

Неизменяемая (unmodifiable) коллекция — это коллекция, у которой методы add(), remove() и set() бросают UnsupportedOperationException. В современном Java их создают фабричными методами List.of(), Set.of(), Map.of() (Java 9) и List.copyOf() (Java 10). Различаются способы деталями: поддержкой null и связью с исходными данными.

Что выведет этот код?

import java.util.Arrays;
import java.util.List;

public class UnmodifiableExample {
    public static void main(String[] args) {
        List<String> fixed = Arrays.asList("a", "b");
        fixed.set(0, "z");
        System.out.println(fixed);

        try {
            fixed.add("c");
        } catch (UnsupportedOperationException e) {
            System.out.println("Arrays.asList: add() запрещён");
        }

        List<String> immutable = List.of("a", "b");
        try {
            immutable.set(0, "z");
        } catch (UnsupportedOperationException e) {
            System.out.println("List.of: set() запрещён");
        }
    }
}

[z, b]
Arrays.asList: add() запрещён
List.of: set() запрещён

Arrays.asList() возвращает список фиксированного размера, а не неизменяемый: заменить элемент можно, изменить размер — нет. Почему изменения такого списка попадают в исходный массив, показано в уроке Backed Collections. Если нужен обычный изменяемый список с начальными элементами, оберните фабрику: new ArrayList<>(List.of("a", "b")).

Потокобезопасные коллекции Java

Обычные ArrayList, HashSet и HashMap не потокобезопасны: при одновременной записи из нескольких потоков данные теряются или итерация падает с ConcurrentModificationException. Для многопоточного кода в Java есть три группы коллекций: унаследованные синхронизированные классы, обёртки Collections.synchronizedXxx() и классы пакета java.util.concurrent (Java 5).

Пример: два потока по 10 000 раз увеличивают общий счётчик в ConcurrentHashMap. Метод merge() выполняет чтение и запись атомарно, поэтому ни одно увеличение не теряется:

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentCounter {
    public static void main(String[] args) throws InterruptedException {
        Map<String, Integer> counts = new ConcurrentHashMap<>();
        Runnable task = () -> {
            for (int i = 0; i < 10_000; i++) {
                counts.merge("clicks", 1, Integer::sum);
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println(counts.get("clicks")); // Вывод: 20000
    }
}

Если заменить ConcurrentHashMap на HashMap, результат станет непредсказуемым: обычно меньше 20000, потому что потоки перезаписывают изменения друг друга. Синхронизация потоков подробно разбирается в уроке Синхронизация потоков.

Уроки модуля по порядку

Модуль «Коллекции» идёт от общего к частному: сначала корневой интерфейс и структуры данных, затем каждая ветка иерархии — списки, множества, очереди, отображения, и в конце инструменты для работы с ними.

Презентация с видео на Patreon →