public class Collections extends Object
{
     static final List EMPTY_LIST; // The empty list (immutable)
     static final Map EMPTY_MAP; // The empty map (immutable).
     static final Set EMPTY_SET; // The empty set (immutable).

     // Добавляет все указанные элементы в указанную коллекцию.
     static <T> boolean addAll(Collection<? super T> c, T... elements);

     // Возвращает вид Deque в виде очереди «последний вошёл — первый вышел» (Lifo).
     static <T> Queue<T> asLifoQueue(Deque<T> deque);

     // Ищет по указанному списку указанного объекта с помощью бинарного алгоритма поиска.
     static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key);

     // Ищет по указанному списку указанного объекта с помощью бинарного алгоритма поиска.
     static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c);

     // Возвращает динамически типобезопасный вид указанной коллекции.
     static <E> Collection<E> checkedCollection(Collection<E> c, Class<E> type);

     // Возвращает динамически типобезопасный вид указанного списка.
     static <E> List<E> checkedList(List<E> list, Class<E> type);

     // Возвращает динамически типобезопасный вид указанной карты.
     static <K,V> Map<K,V> checkedMap(Map<K,V> m, Class<K> keyType, Class<V> valueType);

     // Возвращает динамически типобезопасный вид указанной навигационной карты.
     static <K,V> NavigableMap<K,V> checkedNavigableMap(NavigableMap<K,V> m, Class<K> keyType, Class<V> valueType);

     // Возвращает динамически типобезопасный вид указанного навигационного множества.
     static <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s, Class<E> type)

     // Возвращает динамически типобезопасный вид указанной очереди.
     static <E> Queue<E> checkedQueue(Queue<E> queue, Class<E> type);

     // Возвращает динамически типизированный вид указанного множества.
     static <E> Set<E> checkedSet(Set<E> s, Class<E> type);

     // Возвращает динамически типобезопасный вид указанной отсортированной карты.
     static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m, Class<K> keyType, Class<V> valueType);

     // Возвращает динамически типобезопасный вид указанного отсортированного множества.
     static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, Class<E> type);

     // Копирует все элементы из одного списка в другой.
     static <T> void copy(List<? super T> dest, List<? extends T> src);

     // Возвращает true, если две указанные коллекции не имеют общих элементов.
     static boolean disjoint(Collection<?> c1, Collection<?> c2);

     // Возвращает перечисление, не содержащее элементов.
     static <T> Enumeration<T> emptyEnumeration();

     // Возвращает итератор без элементов.
     static <T> Iterator<T> emptyIterator();

     // Возвращает пустой список (неизменный).
     static final <T> List<T> emptyList();

     // Возвращает итератор списка без элементов.
     static <T> ListIterator<T> emptyListIterator();

     // Возвращает пустое отображение (неизменяемое).
     static final <K,V> Map<K,V> emptyMap();

     // Возвращает пустую навигационную карту (неизменную).
     static final <K,V> NavigableMap<K,V> emptyNavigableMap();

     // Возвращает пустое навигационное множество (неизменное).
     static <E> NavigableSet<E> emptyNavigableSet();

     // Возвращает пустое множество (неизменяемое).
     static final <T> Set<T> emptySet();

     // Возвращает пустую отсортированную карту (неизменную).
     static final <K,V> SortedMap<K,V> emptySortedMap();

     // Возвращает пустое отсортированное множество (неизменяемое).
     static <E> SortedSet<E> emptySortedSet();

     // Возвращает перечисление по указанной коллекции.
     static <T> Enumeration<T> enumeration(Collection<T> c);

     // Заменяет все элементы указанного списка на указанный элемент.
     static <T> void fill(List<? super T> list, T obj);

     // Возвращает количество элементов в указанной коллекции, равное указанному объекту.
     static int frequency(Collection<?> c, Object o);

     // Возвращает начальную позицию первого появления указанного целевой списка внутри указанного списка источников, или -1, если такого явления нет.
     static int indexOfSubList(List<?> source, List<?> target);

     // Возвращает начальную позицию последнего появления указанного целевой списка в указанном списке источников, или -1, если такого явления нет.
     static int lastIndexOfSubList(List<?> source, List<?> target)

     // Возвращает список массивов, содержащий элементы, возвращаемые указанным перечислением, в порядке их возвращения перечислением.
     static <T> ArrayList<T> list(Enumeration<T> e);

     // Возвращает максимальный элемент данной коллекции согласно естественному порядку её элементов.
     static <T extends Object & Comparable<? super T>> max(Collection<? extends T> coll);

     // Возвращает максимальный элемент данной коллекции в соответствии с порядком, вызванным указанным компаратором.
     static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp);

     // Возвращает минимальный элемент данной коллекции согласно естественному порядку её элементов.
     static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll);

     // Возвращает минимальный элемент данной коллекции в соответствии с порядком, вызванным указанным компаратором.
     static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp);

     // Возвращает неизменяемый список, состоящий из n копий указанного объекта.
     static <T> List<T> nCopies(int n, T o);

     // Возвращает последовательное множество, обеспеченное указанным отображением.
     static <E> SequencedSet<E> newSequencedSetFromMap(SequencedMap<E,Boolean> map);

     // Возвращает множество с заданным отображением.
     static <E> Set<E> newSetFromMap(Map<E,Boolean> map);

     // Заменяет все появления одного заданного значения в списке другим.
     static <T> boolean replaceAll(List<T> list, T oldVal, T newVal);

     // Переворачивает порядок элементов в указанном списке.
     static void reverse(List<?> list);

     // Возвращает компаратор, который навязывает обратный естественный порядок на коллекцию объектов, реализующих интерфейс Сопоставимый.
     static <T> Comparator<T> reverseOrder();

     // Возвращает компаратор, который накладывает обратный порядок указанного компаратора.
     static <T> Comparator<T> reverseOrder(Comparator<T> cmp);

     // Вращает элементы в указанном списке на заданное расстояние.
     static void rotate(List<?> list, int distance);

     // Случайным образом переключает указанный список с помощью источника случайности по умолчанию.
     static void shuffle(List<?> list);

     // Случайным образом перестановить указанный список с использованием указанного источника случайности.
     static void shuffle(List<?> list, Random rnd);

     // Случайным образом перестановить указанный список с использованием указанного источника случайности.
     static void shuffle(List<?> list, RandomGenerator rnd);

     // Возвращает неизменяемое множество, содержащее только указанный объект.
     static <T> Set<T> singleton(T o);

     // Возвращает неизменяемый список, содержащий только указанный объект.
     static <T> List<T> singletonList(T o);

     // Возвращает неизменяемое отображение, отображая только заданный ключ в указанное значение.
     static <K,V> Map<K,V> singletonMap(K key, V value);

     // Сортирует указанный список по возрастающему порядку в соответствии с естественным порядком его элементов.
     static <T extends Comparable<? super T>> void sort(List<T> list);

     // Сортирует указанный список по порядку, вызванному указанным компаратором.
     static <T> void sort(List<T> list, Comparator<? super T> c);

     // Меняет местами элементы на указанных позициях в указанном списке.
     static void swap(List<?> list, int i, int j);

     // Возвращает синхронизированную (безопасную для потоков) коллекцию, поддерживаемую указанной коллекцией.
     static <T> Collection<T> synchronizedCollection(Collection<T> c);

     // Возвращает синхронизированный (безопасный для потоков) список, подкреплённый указанным списком.
     static <T> List<T> synchronizedList(List<T> list);

     // Возвращает синхронизированное (безопасное для потоков) отображение, подкрепленное указанным отображением.
     static <K,V> Map<K,V> synchronizedMap(Map<K,V> m);

     // Возвращает синхронизированную (безопасную для потоков) навигационную карту, поддерживаемую указанной навигационной картой.
     static <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m);

     // Возвращает синхронизированный (потоково-безопасный) навигационный набор, поддерживаемый указанным навигационным набором.
     static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s);

     // Возвращает синхронизированный (безопасный для потоков) набор, поддерживаемый указанным набором.
     static <T> Set<T> synchronizedSet(Set<T> s);

     // Возвращает синхронизированную (безопасную для потоков) отсортированную карту, подкрепленную указанной отсортированной картой.
     static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m);

     // Возвращает синхронизированный (безопасный для потоков) отсортированный набор, подкреплённый указанным отсортированным множеством.
     static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s);

     // Возвращает неизменяемый вид указанной коллекции.
     static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c);

     // Возвращает неизменяемый вид указанного списка.
     static <T> List<T> unmodifiableList(List<? extends T> list);

     // Возвращает неизменяемый вид заданной карты.
     static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m);

     // Возвращает неизменяемый вид заданной навигационной карты.
     static <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K,? extends V> m);

     // Возвращает неизменяемый вид указанного навигационного множества.
     static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s);

     // Возвращает неизменяемый вид указанной SequencedCollection.
     static <T> SequencedCollection<T> unmodifiableSequencedCollection(SequencedCollection<? extends T> c);

     // Возвращает неизменяемый вид указанного SequencedMap.
     static <K,V> SequencedMap<K,V> unmodifiableSequencedMap(SequencedMap<? extends K,? extends V> m);

     // Возвращает неизменяемый вид указанного SequencedSet.
     static <T> SequencedSet<T> unmodifiableSequencedSet(SequencedSet<? extends T> s);

     // Возвращает неизменяемый вид указанного множества.
     static <T> Set<T> unmodifiableSet(Set<? extends T> s);

     // Возвращает неизменяемый вид указанной отсортированной карты.
     static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m);

     // Возвращает неизменяемый вид указанного отсортированного множества.
     static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s);
}