Расскажи про иерархию коллекций

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

Коллекции в Java организованы в иерархию интерфейсов и классов, которая определяет, как хранить и обрабатывать группы объектов.

Корневой интерфейс: Iterable

public interface Iterable<T> {
    Iterator<T> iterator();
}

Любой объект, реализующий Iterable, можно перебирать в цикле:

for (String item : iterable) {
    System.out.println(item);
}

Главный интерфейс: Collection

public interface Collection<E> extends Iterable<E> {
    boolean add(E e);
    boolean remove(Object o);
    boolean contains(Object o);
    int size();
}

1. List (упорядоченная, позволяет дубликаты)

ArrayList — динамический массив:

List<String> names = new ArrayList<>();
names.add("Alice");      // O(1) амортизированное
names.get(0);           // O(1)
names.remove(0);        // O(n)

LinkedList — двусвязный список:

List<String> names = new LinkedList<>();
names.add("Alice");      // O(1) в конец
names.get(0);           // O(n)
names.removeFirst();    // O(1)

Успользуйте ArrayList для быстрого доступа по индексу, LinkedList для частых операций с началом/концом.

2. Set (без дубликатов, без порядка)

HashSet — быстро:

Set<String> set = new HashSet<>();
set.add("Alice");      // O(1)
set.contains("Alice"); // O(1)

LinkedHashSet — сохраняет порядок:

Set<String> set = new LinkedHashSet<>();
set.add("Alice");
set.add("Bob");
// Итерирует в порядке добавления

TreeSet — отсортировано:

Set<Integer> numbers = new TreeSet<>();
numbers.add(5);
numbers.add(3);
for (int num : numbers) {
    System.out.println(num);  // 3, 5
}

3. Queue (очередь, FIFO)

LinkedList как очередь:

Queue<String> queue = new LinkedList<>();
queue.offer("task1");
queue.offer("task2");
String first = queue.poll();  // task1

PriorityQueue — по приоритету:

Queue<Integer> pq = new PriorityQueue<>();
pq.offer(5);
pq.offer(1);
System.out.println(pq.poll());  // 1

Deque — двусторонняя очередь:

Deque<String> deque = new ArrayDeque<>();
deque.addFirst("first");
deque.addLast("last");
deque.removeFirst();

4. Map (ключ-значение)

HashMap — быстро:

Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 30);   // O(1)
Integer age = ages.get("Alice");  // O(1)

LinkedHashMap — сохраняет порядок:

Map<String, Integer> ages = new LinkedHashMap<>();
ages.put("Charlie", 35);
ages.put("Alice", 30);
// Итерирует в порядке добавления

TreeMap — отсортировано:

Map<String, Integer> ages = new TreeMap<>();
ages.put("Charlie", 35);
ages.put("Alice", 30);
// Итерирует в порядке ключей

Таблица производительности

*амортизированное в конец **проверка наличия

Синхронизированные версии

Для многопоточности используйте:

List<String> syncList = Collections.synchronizedList(new ArrayList<>());
Map<String, Integer> map = new ConcurrentHashMap<>();

Иерархия

Iterable
  └── Collection
        ├── List (ArrayList, LinkedList)
        ├── Set (HashSet, TreeSet, LinkedHashSet)
        └── Queue (PriorityQueue, Deque)

Map (HashMap, TreeMap, LinkedHashMap)

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

1. Нужна индексация? → ArrayList
2. Частые вставки/удаления в начало? → LinkedList
3. Уникальные значения быстро? → HashSet
4. Отсортированные уникальные? → TreeSet
5. Ключ-значение быстро? → HashMap
6. Отсортировано по ключам? → TreeMap
7. Многопоточность? → ConcurrentHashMap, CopyOnWriteArrayList

Выбор правильной коллекции существенно влияет на производительность приложения. ArrayList и HashMap — самые часто используемые для большинства задач.