Какие знаешь интерфейса в иерархии коллекций?

Иерархия интерфейсов в Java Collections Framework

Java Collections Framework предоставляет иерархию интерфейсов и реализаций для работы с группами объектов. Понимание этой иерархии критически важно для написания эффективного кода.

Основная иерархия

Iterable<E> (интерфейс)
    ↓
Collection<E> (интерфейс)
    ↓
    ├─ List<E>
    ├─ Set<E>
    ├─ Queue<E>
    └─ Deque<E>
        
Map<K,V> (отдельная иерархия)

1. Iterable<E>

Описание: Базовый интерфейс для всех коллекций, которые могут быть итерированы.

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

// Использование
List<String> list = Arrays.asList("A", "B", "C");
for (String item : list) {  // Использует Iterable
    System.out.println(item);
}

// Эквивалентно:
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

Методы:

• Iterator<E> iterator() - возвращает итератор

2. Collection<E>

Описание: Главный интерфейс для всех коллекций (кроме Map).

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

// Использование
Collection<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);

System.out.println(numbers.size());        // 3
System.out.println(numbers.contains(2));   // true
numbers.remove(2);
numbers.clear();

Основные методы:

• add(), remove(), clear() - изменение
• size(), isEmpty(), contains() - просмотр
• addAll(), removeAll(), retainAll() - операции

3. List<E>

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

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);
}

// Реализации
List<String> arrayList = new ArrayList<>();     // Быстрый доступ по индексу
List<String> linkedList = new LinkedList<>();   // Быстрая вставка/удаление
List<String> vector = new Vector<>();           // Synchronized (устаревший)
List<String> copyOnWrite = new CopyOnWriteArrayList<>(); // Потокобезопасный

// Использование
arrayList.add("Apple");
arrayList.add("Banana");
arrayList.add(1, "Orange");  // Вставка по индексу

String first = arrayList.get(0);        // "Apple"
String second = arrayList.get(1);       // "Orange"
String last = arrayList.get(2);         // "Banana"

List<String> sublist = arrayList.subList(0, 2); // ["Apple", "Orange"]

Характеристики:

• Упорядоченность (insertion order)
• Доступ по индексу O(n) для LinkedList, O(1) для ArrayList
• Может содержать null
• Может содержать дубликаты

4. Set<E>

Описание: Неупорядоченная коллекция без дубликатов.

public interface Set<E> extends Collection<E> {
    // Все методы из Collection
    // Нет методов доступа по индексу
}

// Реализации
Set<String> hashSet = new HashSet<>();              // O(1), неупорядочена
Set<String> linkedHashSet = new LinkedHashSet<>();  // O(1), insertion order
Set<String> treeSet = new TreeSet<>();              // O(log n), отсортирована
Set<String> synchronizedSet = Collections.synchronizedSet(new HashSet<>());
Set<String> copyOnWrite = new CopyOnWriteArraySet<>(); // Потокобезопасная

// Использование
hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Apple"); // Не добавляется (дубликат)

System.out.println(hashSet.size()); // 2
System.out.println(hashSet.contains("Apple")); // true

// Итерация (порядок не гарантирован для HashSet)
for (String fruit : hashSet) {
    System.out.println(fruit);
}

Характеристики:

• Без дубликатов
• Порядок не гарантирован (зависит от реализации)
• Использует hashCode() и equals()
• Быстрый поиск

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

5. Queue<E>

Описание: Коллекция для работы по принципу FIFO (First In First Out).

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

// Реализации
Queue<Integer> linkedList = new LinkedList<>();
Queue<Integer> priorityQueue = new PriorityQueue<>(); // По приоритету
Queue<Integer> concurrentQueue = new ConcurrentLinkedQueue<>(); // Потокобезопасная
BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<>(); // Блокирующая

// Использование
linkedList.offer(1);  // Добавляем в конец
linkedList.offer(2);
linkedList.offer(3);

System.out.println(linkedList.poll());  // 1 (извлекаем из начала)
System.out.println(linkedList.peek());  // 2 (смотрим)
System.out.println(linkedList.poll());  // 2

Таблица методов Queue:

6. Deque<E>

Описание: Double Ended Queue - очередь с обоих концов. Может использоваться как Stack и как Queue.

public interface Deque<E> extends Queue<E> {
    // Добавление
    void addFirst(E e);          // Начало, исключение
    void addLast(E e);           // Конец (как Queue.add)
    boolean offerFirst(E e);     // Начало, false
    boolean offerLast(E e);      // Конец (как Queue.offer)
    
    // Удаление
    E removeFirst();             // Начало, исключение
    E removeLast();              // Конец, исключение
    E pollFirst();               // Начало, null
    E pollLast();                // Конец, null
    
    // Просмотр
    E getFirst();                // Начало, исключение
    E getLast();                 // Конец, исключение
    E peekFirst();               // Начало, null
    E peekLast();                // Конец, null
}

// Реализации
Deque<Integer> arrayDeque = new ArrayDeque<>();  // Быстрая, рекомендуется
Deque<Integer> linkedList = new LinkedList<>();   // Тоже реализует Deque
BlockingDeque<Integer> blockingDeque = new LinkedBlockingDeque<>();

// Использование как Stack (LIFO)
arrayDeque.push(1);   // Добавляем в начало
arrayDeque.push(2);
arrayDeque.push(3);

System.out.println(arrayDeque.pop());   // 3 (извлекаем с начала)
System.out.println(arrayDeque.pop());   // 2

// Использование как Queue (FIFO)
Deque<String> queue = new ArrayDeque<>();
queue.addLast("A");
queue.addLast("B");
queue.addLast("C");

System.out.println(queue.removeFirst()); // A
System.out.println(queue.removeFirst()); // B

7. Map<K,V>

Описание: Отображение ключ-значение (отдельная иерархия от Collection).

public interface Map<K,V> {
    // Добавление/Изменение
    V put(K key, V value);
    void putAll(Map<? extends K, ? extends V> m);
    V remove(Object key);
    void clear();
    
    // Просмотр
    V get(Object key);
    int size();
    boolean isEmpty();
    boolean containsKey(Object key);
    boolean containsValue(Object value);
    
    // Вью
    Set<K> keySet();
    Collection<V> values();
    Set<Map.Entry<K,V>> entrySet();
}

// Реализации
Map<String, Integer> hashMap = new HashMap<>();                  // O(1)
Map<String, Integer> linkedHashMap = new LinkedHashMap<>();      // insertion order
Map<String, Integer> treeMap = new TreeMap<>();                  // отсортирована по ключам
Map<String, Integer> concurrentHashMap = new ConcurrentHashMap<>(); // потокобезопасная
Map<String, Integer> identityHashMap = new IdentityHashMap<>();  // По reference
Map<String, Integer> weakHashMap = new WeakHashMap<>();          // Слабые ссылки

// Использование
hashMap.put("Apple", 5);
hashMap.put("Banana", 3);
hashMap.put("Orange", 7);

System.out.println(hashMap.get("Apple"));      // 5
System.out.println(hashMap.containsKey("Banana")); // true
System.out.println(hashMap.size());             // 3

// Итерация
for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {
    System.out.println(entry.getKey() + " = " + entry.getValue());
}

// Или
for (String key : hashMap.keySet()) {
    System.out.println(key + " = " + hashMap.get(key));
}

Полная иерархия Collections

Iterable<E>
    └─ Collection<E>
        ├─ List<E>
        │   ├─ ArrayList<E>
        │   ├─ LinkedList<E>
        │   └─ Vector<E> (устаревший)
        │
        ├─ Set<E>
        │   ├─ HashSet<E>
        │   ├─ LinkedHashSet<E>
        │   └─ SortedSet<E>
        │       └─ TreeSet<E>
        │
        └─ Queue<E>
            ├─ Deque<E>
            │   ├─ ArrayDeque<E>
            │   └─ LinkedList<E>
            ├─ PriorityQueue<E>
            └─ BlockingQueue<E>
                ├─ LinkedBlockingQueue<E>
                ├─ ArrayBlockingQueue<E>
                └─ PriorityBlockingQueue<E>

Map<K,V> (отдельно)
    ├─ HashMap<K,V>
    ├─ LinkedHashMap<K,V>
    ├─ SortedMap<K,V>
    │   └─ TreeMap<K,V>
    ├─ ConcurrentHashMap<K,V>
    ├─ WeakHashMap<K,V>
    └─ IdentityHashMap<K,V>

Сравнительная таблица временной сложности

Лучшие практики

1. List - для упорядоченных данных:

   • ArrayList если нужен частый доступ по индексу
   • LinkedList если нужна частая вставка/удаление в начале

2. Set - для уникальных данных:

   • HashSet если порядок не важен
   • LinkedHashSet если важен insertion order
   • TreeSet если нужна сортировка

3. Queue - для FIFO:

   • LinkedList/ArrayDeque для общего использования
   • PriorityQueue если нужен приоритет
   • BlockingQueue для многопоточности

4. Map - для ключ-значение:

   • HashMap для большинства случаев
   • TreeMap если нужна сортировка
   • ConcurrentHashMap для многопоточности

Заключение

Java Collections Framework предоставляет иерархию интерфейсов: Iterable → Collection → List/Set/Queue и отдельно Map. Каждый интерфейс имеет несколько реализаций с разными характеристиками (скорость, порядок, потокобезопасность). Выбирайте правильную коллекцию для своей задачи!