От чего наследуется List?

От чего наследуется List

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

List наследуется от интерфейса Collection, который в свою очередь наследуется от интерфейса Iterable.

Iterable → Collection → List

Подробная иерархия

1. Iterable (верхний уровень)

public interface Iterable<T> {
    Iterator<T> iterator();
    void forEach(Consumer<? super T> action);
    Spliterator<T> spliterator();
}

Назначение: Определяет, что объект может быть итерирован.

Позволяет:

• Использовать enhanced for loop: for (Object o : list) {}
• Вызывать .forEach() и .spliterator()

2. Collection (промежуточный уровень)

public interface Collection<E> extends Iterable<E> {
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator<E> iterator();
    Object[] toArray();
    <T> T[] toArray(T[] a);
    boolean add(E e);
    boolean remove(Object o);
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
    boolean retainAll(Collection<?> c);
    void clear();
    boolean equals(Object o);
    int hashCode();
}

Дополнительные методы:

• Базовые операции (add, remove, size)
• Массовые операции (addAll, removeAll, retainAll)
• Преобразование в массив (toArray)

3. 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);
    
    // Итератор
    ListIterator<E> listIterator();
    ListIterator<E> listIterator(int index);
}

Специфичные возможности:

• Индексированный доступ: get(index), set(index, value)
• Упорядоченность: Элементы хранятся в определенном порядке
• Дубликаты: List позволяет хранить одинаковые элементы (в отличие от Set)
• ListIterator: Более мощный итератор с поддержкой двусторонней итерации

Граф наследования

┌─────────────┐
│  Iterable   │
│  <T>        │
└──────┬──────┘
       │
       ├─ iterator(): Iterator<T>
       ├─ forEach(Consumer)
       └─ spliterator(): Spliterator<T>

       │
       ▼
┌──────────────────┐
│  Collection      │
│  <E>             │
└──────┬───────────┘
       │
       ├─ size()
       ├─ add(E)
       ├─ remove(Object)
       ├─ contains(Object)
       └─ ...

       │
       ▼
┌──────────────────────────┐
│  List                    │
│  <E>                     │
└──────┬───────────────────┘
       │
       ├─ get(int index)
       ├─ set(int index, E)
       ├─ indexOf(Object)
       ├─ listIterator()
       └─ ...

       │
       ▼
┌──────────────────────────┐
│ Имплементации:           │
│ • ArrayList              │
│ • LinkedList             │
│ • CopyOnWriteArrayList   │
│ • Vector                 │
│ • Collections.emptyList()│
└──────────────────────────┘

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

Использование как Iterable

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");

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

names.forEach(System.out::println);

Использование как Collection

List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);

// Методы Collection
if (numbers.contains(1)) {
    System.out.println("Found");
}
System.out.println("Size: " + numbers.size());
numbers.removeAll(Arrays.asList(2));

Использование специфичных методов List

List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");

// Позиционный доступ
System.out.println(fruits.get(0));  // Apple
fruits.set(1, "Blueberry");

// Поиск
int index = fruits.indexOf("Cherry");  // 2

// Диапазон
List<String> sublist = fruits.subList(0, 2);

// Двусторонняя итерация
ListIterator<String> iter = fruits.listIterator();
while (iter.hasNext()) {
    System.out.println(iter.next());
}
while (iter.hasPrevious()) {
    System.out.println(iter.previous());
}

Ключевые различия

Вывод

List наследуется от Collection, которая наследуется от Iterable. Эта иерархия обеспечивает:

• Iterable → Возможность итерировать
• Collection → Базовые операции работы с коллекциями
• List → Индексированный доступ и упорядоченность

Этот дизайн позволяет писать универсальный код, работающий с любыми коллекциями через интерфейс Collection или Iterable, или специализированный код для List'а с его позиционными операциями.