Что находится на вершине иерархии коллекций

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

На вершине иерархии Java Collections находится интерфейс Iterable (Java 1.5+) и Collection (Java 1.2+).

Общая иерархия

Object
  ├── Iterable (интерфейс)
  │   └── Collection (интерфейс)
  │       ├── List (упорядоченная коллекция)
  │       │   ├── ArrayList
  │       │   ├── LinkedList
  │       │   ├── Vector (legacy)
  │       │   └── CopyOnWriteArrayList
  │       ├── Set (уникальные элементы)
  │       │   ├── HashSet
  │       │   ├── LinkedHashSet
  │       │   ├── TreeSet (упорядоченный)
  │       │   └── EnumSet
  │       └── Queue (порядок обработки FIFO)
  │           ├── LinkedList
  │           ├── PriorityQueue
  │           └── Deque
  └── Map (ключ-значение, НЕ extends Collection!)
      ├── HashMap
      ├── LinkedHashMap
      ├── TreeMap
      ├── WeakHashMap
      └── ConcurrentHashMap

Вершина иерархии: Iterable

Iterable — самый верхний интерфейс для всех коллекций, которые можно перебирать:

public interface Iterable<T> {
    Iterator<T> iterator();  // Единственный метод
    void forEach(Consumer<? super T> action);  // Добавлен в Java 8
    Spliterator<T> spliterator();  // Добавлен в Java 8
}

Практический пример:

// Любой объект, реализующий Iterable, можно использовать в for-each
Iterable<String> names = Arrays.asList("Alice", "Bob", "Charlie");

for (String name : names) {  // Работает благодаря Iterable
    System.out.println(name);
}

// Эквивалент через Iterator
Iterator<String> it = names.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

Collection: второй уровень иерархии

Collection расширяет Iterable и добавляет операции над группами элементов:

public interface Collection<E> extends Iterable<E> {
    // Базовые операции
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    
    // Модификация
    boolean add(E e);
    boolean remove(Object o);
    void clear();
    
    // Массовые операции
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
    boolean retainAll(Collection<?> c);  // Пересечение
    
    // Преобразование
    Object[] toArray();
    <T> T[] toArray(T[] a);
    
    // Потоки (Java 8)
    Stream<E> stream();
    Stream<E> parallelStream();
}

Пример:

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.removeAll(Arrays.asList(1, 2));
System.out.println(numbers.size());      // 1

List: подтип Collection

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);
    
    // Iterator с функциями вперёд-назад
    ListIterator<E> listIterator();
    ListIterator<E> listIterator(int index);
}

Set: подтип Collection

public interface Set<E> extends Collection<E> {
    // Только специфичные методы наследуются из Collection
    // Гарантирует уникальность элементов
    // Переопределение equals() и hashCode() обязательно
}

Map: НЕ extends Collection!

Важно: Map НЕ наследует Collection, так как работает с парами ключ-значение:

public interface Map<K, V> {
    // Доступ
    V get(Object key);
    V put(K key, V value);
    V remove(Object key);
    
    // Представления
    Set<K> keySet();        // Ключи как Set
    Collection<V> values(); // Значения как Collection
    Set<Map.Entry<K, V>> entrySet();  // Пары
    
    // Мощные методы (Java 8+)
    V getOrDefault(Object key, V defaultValue);
    V putIfAbsent(K key, V value);
    void forEach(BiConsumer<? super K, ? super V> action);
    void replaceAll(BiFunction<? super K, ? super V, ? extends V> function);
    V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction);
}

Пример:

Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 25);
ages.put("Bob", 30);

System.out.println(ages.get("Alice"));    // 25
System.out.println(ages.size());          // 2

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

Queue: FIFO коллекция

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<String> queue = new LinkedList<>();
queue.offer("first");
queue.offer("second");
queue.offer("third");

while (!queue.isEmpty()) {
    System.out.println(queue.poll());  // FIFO: first, second, third
}

Сравнение основных типов

Итоговая иерархия

        ┌─────────────┐
        │  Iterable   │  ← Вершина
        └─────────────┘
              │
        ┌─────▼─────┐
        │Collection │  ← Главный интерфейс
        └─────┬─────┘
         ┌────┼────┐
         │    │    │
        List Set Queue    Map (отдельная ветвь)
        │    │    │
    ArrayList HashSet ...

На вершине находится Iterable, обеспечивающий способность к итерации через for-each цикл.