Расскажи все что знаешь про Java Collection Framework

Java Collection Framework — полный обзор

Java Collection Framework (JCF) — это архитектура для хранения и манипуляции группами объектов. Это один из самых важных компонентов Java API.

1. Иерархия интерфейсов

Iterable
  └─ Collection
      ├─ List (упорядоченная коллекция)
      │   ├─ ArrayList
      │   ├─ LinkedList
      │   └─ Vector (устаревший)
      ├─ Set (уникальные элементы)
      │   ├─ HashSet
      │   ├─ LinkedHashSet
      │   ├─ TreeSet
      │   └─ EnumSet
      └─ Queue (FIFO)
          ├─ PriorityQueue
          ├─ Deque (двусторонняя очередь)
          │   ├─ LinkedList
          │   └─ ArrayDeque
          └─ BlockingQueue (многопоточная)
Map (не extends Collection!)
  ├─ HashMap
  ├─ LinkedHashMap
  ├─ TreeMap
  ├─ WeakHashMap
  ├─ IdentityHashMap
  └─ ConcurrentHashMap (многопоточная)

2. Collection Interface

Базовый интерфейс с основными операциями:

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

3. List Interface

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

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);
    
    // Подсписки
    List<E> subList(int fromIndex, int toIndex);
}

// Практические примеры
List<String> arrayList = new ArrayList<>();
arrayList.add("Java");
arrayList.add("Python");
arrayList.add(1, "C++"); // Вставка по индексу
String first = arrayList.get(0);

List<Integer> linkedList = new LinkedList<>();
linkedList.add(10);
linkedList.addFirst(5);  // Вставка в начало
linkedList.addLast(20);  // Вставка в конец

4. ArrayList vs LinkedList

public class ListComparison {
    public static void main(String[] args) {
        // ArrayList — быстрый случайный доступ
        List<Integer> arrayList = new ArrayList<>();
        arrayList.add(1);        // O(1) амортизированный
        arrayList.get(0);        // O(1)
        arrayList.remove(0);     // O(n) — нужно сдвигать элементы
        
        // LinkedList — быстрые добавления/удаления в начало
        List<Integer> linkedList = new LinkedList<>();
        linkedList.add(1);       // O(1)
        linkedList.addFirst(0);  // O(1)
        linkedList.get(0);       // O(n) — нужно проходить с начала
    }
}

5. Set Interface

Коллекция без дубликатов:

// HashSet — быстрые операции, нет порядка
Set<String> hashSet = new HashSet<>();
hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Apple"); // Не добавится (дубликат)
System.out.println(hashSet.size()); // 2

// LinkedHashSet — сохраняет порядок вставки
Set<String> linkedSet = new LinkedHashSet<>();
linkedSet.add("First");
linkedSet.add("Second");
linkedSet.add("Third");
// Итерация в порядке вставки: First, Second, Third

// TreeSet — отсортированный
Set<Integer> treeSet = new TreeSet<>();
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);
// Итерация: 1, 2, 3 (отсортировано)

6. Map Interface

Отображение ключ-значение:

public interface Map<K, V> {
    V put(K key, V value);
    V get(Object key);
    V remove(Object key);
    boolean containsKey(Object key);
    boolean containsValue(Object value);
    Set<K> keySet();
    Collection<V> values();
    Set<Map.Entry<K, V>> entrySet();
}

// HashMap — оптимален для большинства случаев
Map<String, Integer> map = new HashMap<>();
map.put("Alice", 25);
map.put("Bob", 30);
System.out.println(map.get("Alice")); // 25

// Итерация по ключам
for (String key : map.keySet()) {
    System.out.println(key + ": " + map.get(key));
}

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

// TreeMap — отсортирован по ключам
Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Charlie", 35);
treeMap.put("Alice", 25);
treeMap.put("Bob", 30);
// Итерация в алфавитном порядке: Alice, Bob, Charlie

// ConcurrentHashMap — многопоточный HashMap
Map<String, String> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put("thread-safe", "yes");

7. Queue и Deque

// Queue — FIFO (First In, First Out)
Queue<Integer> queue = new LinkedList<>();
queue.add(1);        // Добавить в конец
queue.offer(2);      // Более безопасно
Integer first = queue.poll();  // Удалить из начала

// Deque — двусторонняя очередь
Deque<String> deque = new ArrayDeque<>();
deque.addFirst("Front");
deque.addLast("Back");
deque.removeFirst();  // Удалить с начала
deque.removeLast();   // Удалить с конца

// PriorityQueue — приоритетная очередь
Queue<Integer> pq = new PriorityQueue<>();
pq.add(3);
pq.add(1);
pq.add(2);
while (!pq.isEmpty()) {
    System.out.println(pq.poll()); // 1, 2, 3 (отсортировано)
}

8. Iterator

Безопасный способ обхода коллекции:

List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

// Традиционный способ
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String element = it.next();
    if (element.equals("B")) {
        it.remove(); // Безопасное удаление
    }
}

// Foreach (работает для Iterable)
for (String s : list) {
    System.out.println(s);
}

// Stream API (Java 8+)
list.stream()
    .filter(s -> !s.equals("A"))
    .forEach(System.out::println);

9. Синхронизированные коллекции

// Collections.synchronizedList — обёртка
List<String> syncList = Collections.synchronizedList(
    new ArrayList<>()
);

// ConcurrentHashMap — встроенная многопоточность
Map<String, String> concurrentMap = new ConcurrentHashMap<>();

// CopyOnWriteArrayList — оптимален для читающих операций
List<String> copyOnWrite = new CopyOnWriteArrayList<>();

10. Практический пример: обработка данных

public class CollectionExample {
    public static void main(String[] args) {
        // Создание и заполнение
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 25));
        people.add(new Person("Bob", 30));
        people.add(new Person("Charlie", 25));
        
        // Группировка по возрасту (Stream API)
        Map<Integer, List<Person>> byAge = people.stream()
            .collect(Collectors.groupingBy(Person::getAge));
        
        // Сортировка
        people.sort((p1, p2) -> p1.getAge() - p2.getAge());
        
        // Фильтрация
        List<String> names = people.stream()
            .filter(p -> p.getAge() > 25)
            .map(Person::getName)
            .collect(Collectors.toList());
    }
}

class Person {
    String name;
    int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() { return name; }
    public int getAge() { return age; }
}

11. Выбор коллекции

Заключение

Java Collection Framework — это мощный инструмент для работы с группами объектов. Выбор правильной коллекции критичен для производительности. ArrayList для произвольного доступа, LinkedList для добавлений/удалений, HashSet для уникальности, HashMap для отображений — это обычно всё, что вам нужно.