Является ли Collections базовым классом?

Является ли Collections базовым классом?

Коротко: Нет, Collections — это утилитный класс (utility class), а не базовый класс (base class).

1. Что такое Collections?

Collections — это финальный класс (java.util.Collections) с статическими методами для работы с коллекциями:

public final class Collections {
    // Конструктор приватный — нельзя создать экземпляр
    private Collections() {
    }
    
    // Только статические методы
    public static <T> List<T> unmodifiableList(List<T> list) { ... }
    public static <T> List<T> synchronizedList(List<T> list) { ... }
    public static <T extends Comparable<? super T>> void sort(List<T> list) { ... }
    // и множество других...
}

Это НЕ базовый класс, потому что:

// ❌ Нельзя наследовать
class MyCollections extends Collections {  // Compile error!
    // Collections is final
}

// ❌ Нельзя создать экземпляр
Collections coll = new Collections();  // Compile error!
// Constructor is private

// ✅ Можно использовать только статические методы
Collections.sort(myList);
Collections.shuffle(myList);
Collections.reverse(myList);

2. Базовые классы и интерфейсы для коллекций

Это иерархия реальных базовых классов:

// БАЗОВЫЕ ИНТЕРФЕЙСЫ
public interface Collection<E> { 
    // Базовый интерфейс для всех коллекций
    boolean add(E e);
    boolean remove(Object o);
    Iterator<E> iterator();
    // и т.д.
}

public interface List<E> extends Collection<E> {
    // Упорядоченная коллекция
    E get(int index);
    void add(int index, E element);
}

public interface Set<E> extends Collection<E> {
    // Уникальные элементы
}

public interface Map<K, V> {
    // Пары ключ-значение
    V put(K key, V value);
    V get(Object key);
}

// АБСТРАКТНЫЕ БАЗОВЫЕ КЛАССЫ
public abstract class AbstractCollection<E> implements Collection<E> {
    // Базовая реализация Collection
    public abstract Iterator<E> iterator();
    public boolean contains(Object o) { ... }
}

public abstract class AbstractList<E> extends AbstractCollection<E> 
    implements List<E> {
    // Базовая реализация List
}

public abstract class AbstractSet<E> extends AbstractCollection<E> 
    implements Set<E> {
    // Базовая реализация Set
}

public abstract class AbstractMap<K, V> implements Map<K, V> {
    // Базовая реализация Map
}

// КОНКРЕТНЫЕ РЕАЛИЗАЦИИ
public class ArrayList<E> extends AbstractList<E> { ... }
public class LinkedList<E> extends AbstractSequentialList<E> { ... }
public class HashSet<E> extends AbstractSet<E> { ... }
public class HashMap<K, V> extends AbstractMap<K, V> { ... }

Иерархия:

Collection<E> (interface)
  ├── List<E> (interface)
  │   └── AbstractList<E> (abstract class)
  │       ├── ArrayList<E>
  │       ├── LinkedList<E>
  │       └── Vector<E>
  ├── Set<E> (interface)
  │   └── AbstractSet<E> (abstract class)
  │       ├── HashSet<E>
  │       ├── TreeSet<E>
  │       └── LinkedHashSet<E>
  └── Queue<E> (interface)
      ├── AbstractQueue<E> (abstract class)
      └── PriorityQueue<E>

Map<K, V> (interface)
  └── AbstractMap<K, V> (abstract class)
      ├── HashMap<K, V>
      ├── TreeMap<K, V>
      ├── LinkedHashMap<K, V>
      └── WeakHashMap<K, V>

3. Что делает Collections утилитным классом

public class CollectionsUtilityExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5);
        
        // Сортировка
        Collections.sort(numbers);
        System.out.println(numbers);  // [1, 1, 3, 4, 5]
        
        // Перемешивание
        Collections.shuffle(numbers);
        
        // Реверс
        Collections.reverse(numbers);
        
        // Поиск
        int index = Collections.binarySearch(numbers, 4);
        
        // Статистика
        Integer max = Collections.max(numbers);
        Integer min = Collections.min(numbers);
        
        // Заполнение
        List<String> list = new ArrayList<>(3);
        Collections.fill(list, "default");
        
        // Неизменяемые коллекции
        List<String> immutable = Collections.unmodifiableList(
            Arrays.asList("a", "b", "c")
        );
        // immutable.add("d");  // Throws UnsupportedOperationException
        
        // Синхронизированные коллекции
        List<String> synchronized_list = Collections.synchronizedList(
            new ArrayList<>()
        );
    }
}

4. Сравнение с Array утилитным классом

Collections похож на Arrays — оба утилитные классы:

// Arrays — утилитный класс для массивов
public final class Arrays {
    private Arrays() {}
    
    public static <T> void sort(T[] a) { ... }
    public static <T> int binarySearch(T[] a, T key) { ... }
    public static <T> List<T> asList(T... a) { ... }
    public static void fill(Object[] a, Object val) { ... }
    public static boolean equals(Object[] a, Object[] a2) { ... }
    public static String toString(Object[] a) { ... }
}

// Collections — утилитный класс для коллекций
public final class Collections {
    private Collections() {}
    
    public static <T extends Comparable<? super T>> void sort(List<T> list) { ... }
    public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) { ... }
    public static <T> List<T> unmodifiableList(List<T> list) { ... }
    public static <T> void fill(List<? super T> list, T obj) { ... }
    // и т.д.
}

5. Collections vs Коллекции

Collections (утилитный класс) — это НЕ то же самое что Collections (фреймворк):

// Collections Framework включает:
// - Интерфейсы: Collection, List, Set, Map
// - Абстрактные классы: AbstractCollection, AbstractList, AbstractSet, AbstractMap
// - Реализации: ArrayList, LinkedList, HashSet, HashMap, и т.д.
// - Утилитный класс Collections для работы с коллекциями

public class CollectionsFrameworkExample {
    public static void main(String[] args) {
        // Collections Framework использует интерфейсы
        Collection<String> collection = new ArrayList<>();  // Interface
        List<String> list = new LinkedList<>();             // Interface
        Set<String> set = new HashSet<>();                  // Interface
        Map<String, Integer> map = new HashMap<>();         // Interface
        
        // Collections утилитный класс — статические методы
        Collections.sort(list);        // Сортирует List
        Collections.shuffle(list);     // Перемешивает
        Collections.reverse(list);     // Переворачивает
    }
}

6. Когда нужны Collections методы

public class CollectionsUsageExample {
    public static void main(String[] args) {
        // ✅ Необходимые операции
        List<String> names = new ArrayList<>(Arrays.asList(
            "Charlie", "Alice", "Bob"
        ));
        
        // Сортировка
        Collections.sort(names);
        // [Alice, Bob, Charlie]
        
        // Синхронизированный список (для многопоточности)
        List<String> syncList = Collections.synchronizedList(
            new ArrayList<>(names)
        );
        
        // Защита от изменений
        List<String> immutableNames = Collections.unmodifiableList(names);
        
        // Пустые коллекции
        List<Object> empty = Collections.emptyList();
        Set<Object> emptySet = Collections.emptySet();
        Map<Object, Object> emptyMap = Collections.emptyMap();
        
        // Коллекция с одним элементом
        List<String> singleton = Collections.singletonList("Only one");
        
        // Копирование
        List<String> source = new ArrayList<>(Arrays.asList("a", "b", "c"));
        List<String> destination = new ArrayList<>(source.size());
        Collections.copy(destination, source);
        
        // Поиск
        int index = Collections.binarySearch(names, "Alice");
        
        // Подстановки в unmodifiable коллекции
        Collections.replaceAll(names, "Alice", "Alicia");
        
        // Частота элемента
        int frequency = Collections.frequency(names, "Bob");
    }
}

7. Ключевые методы Collections

public class CollectionsKeyMethods {
    // Сортировка и поиск
    public static <T extends Comparable<? super T>> void sort(List<T> list);
    public static <T> void sort(List<T> list, Comparator<? super T> c);
    public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key);
    
    // Операции
    public static void reverse(List<?> list);
    public static void shuffle(List<?> list);
    public static void rotate(List<?> list, int distance);
    public static <T extends Comparable<? super T>> void fill(List<? super T> list, T obj);
    public static void replaceAll(List<T> list, T oldVal, T newVal);
    
    // Статистика
    public static <T extends Comparable<? super T>> T max(Collection<T> coll);
    public static <T extends Comparable<? super T>> T min(Collection<T> coll);
    public static int frequency(Collection<?> c, Object o);
    
    // Неизменяемые коллекции
    public static <T> Collection<T> unmodifiableCollection(Collection<T> c);
    public static <T> List<T> unmodifiableList(List<T> list);
    public static <T> Set<T> unmodifiableSet(Set<T> s);
    public static <K, V> Map<K, V> unmodifiableMap(Map<K, V> m);
    
    // Синхронизированные коллекции
    public static <T> Collection<T> synchronizedCollection(Collection<T> c);
    public static <T> List<T> synchronizedList(List<T> list);
    public static <T> Set<T> synchronizedSet(Set<T> s);
    public static <K, V> Map<K, V> synchronizedMap(Map<K, V> m);
    
    // Пустые коллекции
    public static <T> List<T> emptyList();
    public static <T> Set<T> emptySet();
    public static <T> SortedSet<T> emptySortedSet();
    public static <K, V> Map<K, V> emptyMap();
    
    // Сингултон
    public static <T> List<T> singletonList(T o);
    public static <T> Set<T> singleton(T o);
    public static <K, V> Map<K, V> singletonMap(K key, V value);
    
    // Копирование
    public static <T> void copy(List<? super T> dest, List<? extends T> src);
    
    // Диапазон
    public static <T> List<T> nCopies(int n, T o);
}

8. Вывод: Collections vs базовый класс

public class ComparisonTable {
    // COLLECTIONS (утилитный класс)
    // ✅ Финальный класс (final)
    // ✅ Конструктор приватный (private)
    // ✅ Только статические методы
    // ✅ Не наследуемый
    // ✅ Помощник для работы с коллекциями
    
    // БАЗОВЫЕ КЛАССЫ ДЛЯ КОЛЛЕКЦИЙ
    // ✅ AbstractCollection, AbstractList, AbstractSet, AbstractMap
    // ✅ Можно наследовать
    // ✅ Имеют конкретные реализации методов
    // ✅ Предоставляют базовую функциональность
    
    // ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();  // Использует ArrayList
        Collections.sort(list);                  // Использует Collections
        
        // Collections НЕ базовый класс для ArrayList
        // Collections — утилитный класс для работы с ArrayList
    }
}

Best Practices

public class CollectionsBestPractices {
    // 1. ✅ Используй Collections для утилитных операций
    Collections.sort(list);
    
    // 2. ✅ Используй интерфейсы (Collection, List, Set, Map) для типов
    public void process(Collection<String> items) { }
    
    // 3. ✅ Используй абстрактные классы при создании пользовательских коллекций
    class MyList<T> extends AbstractList<T> { }
    
    // 4. ❌ Не наследуй от Collections (это утилитный класс)
    // class MyCollections extends Collections { }
    
    // 5. ✅ Используй unmodifiable коллекции для защиты от изменений
    List<String> immutable = Collections.unmodifiableList(list);
    
    // 6. ✅ Знай разницу между Collections и Collections Framework
}

Вывод

Collections НЕ является базовым классом. Это утилитный класс с статическими методами для работы с коллекциями.

Базовые классы для коллекций:

• Интерфейсы: Collection, List, Set, Map
• Абстрактные классы: AbstractCollection, AbstractList, AbstractSet, AbstractMap

Collections — это помощник для выполнения типичных операций над коллекциями (сортировка, поиск, синхронизация, создание неизменяемых коллекций).