Что такое Collection Framework?

Что такое Collection Framework

Java Collection Framework — это набор интерфейсов и классов для хранения, управления и манипулирования группами объектов. Это фундаментальный инструмент в любом Java приложении.

Основной интерфейс: Collection

public interface Collection<E> extends Iterable<E> {
    // Модификация
    boolean add(E e);
    boolean addAll(Collection<? extends E> c);
    boolean remove(Object o);
    boolean removeAll(Collection<?> c);
    void clear();
    
    // Поиск
    boolean contains(Object o);
    boolean containsAll(Collection<?> c);
    
    // Размер
    int size();
    boolean isEmpty();
    
    // Итерирование
    Iterator<E> iterator();
}

Иерархия Collection Framework

Iterable<E> (интерфейс для обхода)
    |
    └─ Collection<E> (базовый интерфейс)
         ├─ List<E> (упорядоченная коллекция, дубликаты разрешены)
         │  ├─ ArrayList<E> (массив, быстрый доступ)
         │  ├─ LinkedList<E> (связный список, быстрые вставки)
         │  └─ Vector<E> (синхронизированный массив, устаревший)
         │
         ├─ Set<E> (уникальные элементы, без порядка)
         │  ├─ HashSet<E> (на основе хеш-таблицы, быстро)
         │  ├─ TreeSet<E> (отсортирована, красно-чёрное дерево)
         │  └─ LinkedHashSet<E> (с порядком вставки)
         │
         └─ Queue<E> (очередь, FIFO)
            ├─ LinkedList<E> (двусторонняя очередь)
            ├─ PriorityQueue<E> (куча, приоритет)
            └─ Deque<E> (двусторонняя очередь)

Map<K,V> (отдельная иерархия, ключ-значение)
├─ HashMap<K,V> (быстро, без порядка)
├─ TreeMap<K,V> (отсортирована по ключам)
├─ LinkedHashMap<K,V> (с порядком вставки)
└─ ConcurrentHashMap<K,V> (потокобезопасная)

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

1. List (Список)

Упорядоченная коллекция, поддерживает индексный доступ:

public interface List<E> extends Collection<E> {
    // Индексный доступ
    E get(int index);
    E set(int index, E element);
    void add(int index, E element);
    E remove(int index);
    
    // Поиск
    int indexOf(Object o);
    int lastIndexOf(Object o);
    
    // Подлист
    List<E> subList(int fromIndex, int toIndex);
}

Реализации:

// ArrayList: быстрый доступ, медленная вставка в середину
List<String> list = new ArrayList<>();
list.add("first");       // O(1)
list.get(0);             // O(1)
list.add(0, "zero");     // O(n) — нужно сдвинуть элементы

// LinkedList: быстрая вставка, медленный доступ
List<String> linked = new LinkedList<>();
linked.add("first");     // O(1)
linked.get(0);           // O(n) — нужно пройти по цепи
linked.add(0, "zero");   // O(1)

2. Set (Множество)

Коллекция без дубликатов, без гарантированного порядка:

public interface Set<E> extends Collection<E> {
    // Все методы из Collection
    // Гарантия: нет дубликатов
}

// HashSet: быстро, без порядка
Set<String> set = new HashSet<>();
set.add("apple");
set.add("apple");  // не добавит (дубликат)
set.size();        // 1

// TreeSet: отсортирована, медленнее
Set<String> sorted = new TreeSet<>();
sorted.add("cherry");
sorted.add("apple");
sorted.add("banana");
// Итерирование: apple, banana, cherry (отсортирована)

// LinkedHashSet: с порядком вставки
Set<String> ordered = new LinkedHashSet<>();
ordered.add("first");
ordered.add("second");
ordered.add("third");
// Итерирование: first, second, third (порядок вставки)

3. Queue (Очередь)

Коллекция FIFO (first-in-first-out):

public interface Queue<E> extends Collection<E> {
    // Вставка
    boolean offer(E e);    // добавить в конец
    
    // Удаление
    E poll();              // удалить с начала (null если пусто)
    E remove();            // удалить с начала (исключение если пусто)
    
    // Просмотр
    E peek();              // посмотреть начало (null если пусто)
    E element();           // посмотреть начало (исключение если пусто)
}

// LinkedList как очередь
Queue<String> queue = new LinkedList<>();
queue.offer("first");
queue.offer("second");
queue.poll();  // вернёт "first"

// PriorityQueue: приоритет вместо FIFO
Queue<Integer> pq = new PriorityQueue<>();
pq.offer(5);
pq.offer(1);
pq.offer(3);
pq.poll();  // вернёт 1 (минимальный элемент)

// Deque: двусторонняя очередь
Deque<String> deque = new LinkedList<>();
deque.addFirst("head");
deque.addLast("tail");
deque.removeFirst();  // O(1)
deque.removeLast();   // O(1)

4. Map (Словарь)

Пары ключ-значение:

public interface Map<K, V> {
    // Вставка и получение
    V put(K key, V value);
    V get(Object key);
    V remove(Object key);
    void clear();
    
    // Проверки
    boolean containsKey(Object key);
    boolean containsValue(Object value);
    int size();
    boolean isEmpty();
    
    // Представления
    Set<K> keySet();
    Collection<V> values();
    Set<Map.Entry<K, V>> entrySet();
}

// HashMap: быстро, без порядка
Map<String, Integer> map = new HashMap<>();
map.put("apple", 5);
map.get("apple");  // O(1)

// TreeMap: отсортирована по ключам
Map<String, Integer> sorted = new TreeMap<>();
sorted.put("zebra", 1);
sorted.put("apple", 2);
// Итерирование: apple, zebra (отсортировано)

// LinkedHashMap: с порядком вставки
Map<String, Integer> ordered = new LinkedHashMap<>();
ordered.put("first", 1);
ordered.put("second", 2);
// Итерирование: first, second (порядок вставки)

Сравнение реализаций

┌────────────┬────────┬────────┬────────┬────────┬──────────┐
│ Класс      │ add    │ get    │ remove │ size   │ Порядок  │
├────────────┼────────┼────────┼────────┼────────┼──────────┤
│ ArrayList  │ O(1)   │ O(1)   │ O(n)   │ O(1)   │ Индекс   │
│ LinkedList │ O(1)   │ O(n)   │ O(1)   │ O(1)   │ Индекс   │
│ HashSet    │ O(1)   │ O(1)   │ O(1)   │ O(1)   │ Нет      │
│ TreeSet    │ O(logn)│ O(logn)│ O(logn)│ O(1)   │ Да       │
│ HashMap    │ O(1)   │ O(1)   │ O(1)   │ O(1)   │ Нет      │
│ TreeMap    │ O(logn)│ O(logn)│ O(logn)│ O(1)   │ Да       │
└────────────┴────────┴────────┴────────┴────────┴──────────┘

Iterator (Итератор)

Унифицированный способ обхода коллекций:

public interface Iterator<E> {
    boolean hasNext();    // есть ли ещё элементы
    E next();             // получить следующий элемент
    void remove();        // удалить текущий элемент
}

// Способ 1: Iterator явно
List<String> list = new ArrayList<>();
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

// Способ 2: for-each цикл (работает со всеми Collection)
for (String item : list) {
    System.out.println(item);
}

// Способ 3: Stream API (Java 8+)
list.forEach(System.out::println);
list.stream()
    .filter(s -> s.length() > 3)
    .map(String::toUpperCase)
    .forEach(System.out::println);

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

// Синхронизированные обёртки (старый подход)
List<String> syncList = Collections.synchronizedList(new ArrayList<>());
Map<String, Integer> syncMap = Collections.synchronizedMap(new HashMap<>());

// Concurrent коллекции (современный подход)
import java.util.concurrent.*;

ConcurrentHashMap<String, Integer> concMap = new ConcurrentHashMap<>();
CopyOnWriteArrayList<String> cowList = new CopyOnWriteArrayList<>();

// Concurrent очередь
BlockingQueue<String> queue = new LinkedBlockingQueue<>();
queue.put("item");       // ждёт если очередь полна
String item = queue.take();  // ждёт если очередь пуста

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

// Удаление дубликатов
List<String> list = Arrays.asList("a", "b", "a", "c", "b");
Set<String> unique = new HashSet<>(list);
list = new ArrayList<>(unique);

// Сортировка
List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
Collections.sort(numbers);
// numbers: [1, 1, 3, 4, 5, 9]

// Кастомная сортировка
Collections.sort(numbers, (a, b) -> b.compareTo(a));  // убывающий порядок

// Поиск
int index = Collections.binarySearch(numbers, 4);

// Обращение
Collections.reverse(numbers);

// Перемешивание
Collections.shuffle(numbers);

// Частое слово в тексте
List<String> words = Arrays.asList("hello", "world", "hello");
Map<String, Integer> frequency = new HashMap<>();
for (String word : words) {
    frequency.put(word, frequency.getOrDefault(word, 0) + 1);
}

Stream API (функциональный подход)

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// Фильтр и преобразование
names.stream()
    .filter(n -> n.length() > 3)
    .map(String::toUpperCase)
    .forEach(System.out::println);
    // Output: ALICE, CHARLIE

// Группировка
Map<Integer, List<String>> byLength = names.stream()
    .collect(Collectors.groupingBy(String::length));
// {3: [Bob], 5: [Alice], 7: [Charlie]}

// Сумма
int total = Arrays.asList(1, 2, 3, 4)
    .stream()
    .mapToInt(Integer::intValue)
    .sum();

Вывод

• Collection Framework — универсальный инструмент для работы с группами объектов
• Иерархия: Collection (List, Set, Queue) и Map
• List: ArrayList для доступа, LinkedList для вставок
• Set: HashSet для скорости, TreeSet для порядка
• Map: HashMap для скорости, TreeMap для порядка
• Queue: LinkedList или PriorityQueue
• Iterator: единый способ обхода всех коллекций
• Stream API: функциональный подход (Java 8+)
• Concurrent: потокобезопасные варианты для многопоточных приложений