Класс Collections

public class Collections
extends Object

Этот класс состоит исключительно из статических методов, которые работают с коллекциями или возвращают их. Он содержит полиморфные алгоритмы, работающие с коллекциями, "обёртки", которые возвращают новую коллекцию, поддерживаемую заданной коллекцией, и несколько других элементов.

Все методы этого класса выбрасывают исключение NullPointerException, если предоставленные им коллекции или объекты классов равны null.

Документация полиморфных алгоритмов, содержащихся в этом классе, обычно включает краткое описание реализации. Такие описания следует рассматривать как примечания к реализации, а не как части спецификации. Разработчики могут свободно подставлять другие алгоритмы, если соблюдается сама спецификация. (Например, алгоритм, используемый sort, не обязательно должен быть слиянием, но он должен быть стабильным.)

«Деструктивные» алгоритмы, содержащиеся в этом классе, то есть алгоритмы, которые изменяют коллекцию, на которой они работают, определены как выбрасывающие исключение UnsupportedOperationException, если коллекция не поддерживает соответствующие примитивы мутации, такие как метод set. Эти алгоритмы могут, но не обязаны, выбрасывать это исключение, если вызов не окажет никакого влияния на коллекцию. Например, вызов метода sort для неизменяемого списка, который уже отсортирован, может или не может вызвать исключение UnsupportedOperationException.

Этот класс является членом Java Collections Framework.

Since:
1.2
См. также:
Collection, Set, List, Map

Краткое описание полей

Модификатор и тип Поле Описание
static List EMPTY_LIST

Пустой список (неизменяемый).
static Map EMPTY_MAP

Пустой словарь (неизменяемый).
static Set EMPTY_SET

Пустой набор (неизменяемый).

Методы

Модификатор и тип Метод Описание
static <T> boolean addAll​(Collection<? super T> c, T... elements)

Добавляет все указанные элементы в указанную коллекцию.
static <T> Queue<T> asLifoQueue​(Deque<T> deque)

Возвращает представление Deque как очереди «последний вошел — первый вышел» (Lifo) Queue.
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)

Копирует все элементы из одного списка в другой.
static boolean disjoint​(Collection<?> c1, Collection<?> c2)

Возвращает true, если у двух указанных коллекций нет общих элементов.
static <T> Enumeration<T> emptyEnumeration()

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

Возвращает итератор без элементов.
static <T> List<T> emptyList()

Возвращает пустой список (неизменяемый).
static <T> ListIterator<T> emptyListIterator()

Возвращает итератор списка без элементов.
static <K,​V>
Map<K,​V>		 emptyMap()

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

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

Возвращает пустой навигационный набор (неизменяемый).
static <T> Set<T> emptySet()

Возвращает пустой набор (неизменяемый).
static <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)

Возвращает количество элементов в указанной коллекции, равных указанному объекту.
static int indexOfSubList​(List<?> source, List<?> target)

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

Возвращает начальную позицию последнего вхождения указанного целевого списка в указанном исходном списке или -1, если такого вхождения нет.
static <T> ArrayList<T> list​(Enumeration<T> e)

Возвращает список массивов, содержащий элементы, возвращаемые указанным перечислением в том порядке, в котором они возвращаются перечислением.
static <T extends Object & Comparable<? super T>>
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)

Возвращает минимальный элемент данной коллекции в соответствии с порядком, заданным указанным компаратором.
static <T> List<T> nCopies​(int n, T o)

Возвращает неизменяемый список, состоящий из n копий указанного объекта.
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()

Возвращает компаратор, который накладывает обратный порядок естественного упорядочения на коллекцию объектов, реализующих интерфейс Comparable.
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 <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)

Возвращает неизменяемый вид указанного сортируемого набора.
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)

Возвращает неизменяемый вид указанного сортируемого набора.

Методы, объявленные в классе java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Поля

EMPTY_SET

public static final Set EMPTY_SET

Пустой набор (неизменяемый). Этот набор сериализуем.

См. также:
emptySet()

EMPTY_LIST

public static final List EMPTY_LIST

Пустой список (неизменяемый). Этот список сериализуем.

См. также:
emptyList()

EMPTY_MAP

public static final Map EMPTY_MAP

Пустая карта (неизменяемая). Эта карта сериализуема.

С момента:
1.3
См. также:
emptyMap()

Методы

sort

public static <T extends Comparable<? super T>> void sort(List<T> list)

Сортирует указанный список в порядке возрастания в соответствии с естественным порядком элементов. Все элементы в списке должны реализовывать интерфейс Comparable. Кроме того, все элементы в списке должны быть взаимосравнимы (то есть, e1.compareTo(e2) не должно выбрасывать ClassCastException для любых элементов e1 и e2 в списке).

Эта сортировка гарантированно стабильна: равные элементы не будут переупорядочены в результате сортировки.

Указанный список должен быть изменяемым, но не обязательно изменяемым по размеру.

Примечание к реализации:
Эта реализация делегирует вызов методу List.sort(Comparator) с использованием указанного списка и компаратора null.
Параметры типа:
T - класс объектов в списке
Параметры:
list - сортируемый список.
Исключения:
ClassCastException - если список содержит элементы, которые не являются взаимосравнимыми (например, строки и целые числа).
UnsupportedOperationException - если итератор списка указанного списка не поддерживает операцию set.
IllegalArgumentException - (необязательно) если реализация обнаруживает, что естественный порядок элементов списка нарушает контракт Comparable
См. также:
List.sort(Comparator)

sort

public static <T> void sort(List<T> list,
                            Comparator<? super T> c)

Сортирует указанный список в соответствии с порядком, индуцированным указанным компаратором. Все элементы в списке должны быть взаимосравнимы с помощью указанного компаратора (то есть, c.compare(e1, e2) не должно выбрасывать ClassCastException для любых элементов e1 и e2 в списке).

Эта сортировка гарантированно стабильна: равные элементы не будут переупорядочены в результате сортировки.

Указанный список должен быть изменяемым, но не обязательно изменяемым по размеру.

Примечание к реализации:
Эта реализация делегирует вызов методу List.sort(Comparator) с использованием указанного списка и компаратора.
Параметры типа:
T - класс объектов в списке
Параметры:
list - сортируемый список.
c - компаратор, определяющий порядок списка. Значение null указывает, что следует использовать естественный порядок элементов.
Исключения:
ClassCastException - если список содержит элементы, которые не являются взаимосравнимыми с использованием указанного компаратора.
UnsupportedOperationException - если итератор указанного списка не поддерживает операцию set.
IllegalArgumentException - (необязательно) если компаратор нарушает контракт Comparator
См. также:
List.sort(Comparator)

binarySearch

public static <T> int binarySearch(List<? extends Comparable<? super T>> list,
                                   T key)

Ищет указанный объект в указанном списке с помощью алгоритма бинарного поиска. Список должен быть отсортирован по возрастанию в соответствии с естественным порядком элементов (как методом sort(List)) до вызова этого метода. Если он не отсортирован, результаты неопределены. Если список содержит несколько элементов, равных указанному объекту, нет гарантии, какой из них будет найден.

Этот метод работает за время log(n) для списка с «случайным доступом» (который обеспечивает доступ к позиции практически за постоянное время). Если указанный список не реализует интерфейс RandomAccess и большой, этот метод выполнит бинарный поиск на основе итератора, который выполнит O(n) обходов связей и O(log n) сравнений элементов.

Параметры типа:
T - класс объектов в списке
Параметры:
list - список для поиска.
key - ключ для поиска.
Возвращает:
индекс ключа поиска, если он содержится в списке; в противном случае, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в список: индекс первого элемента, большего ключа, или list.size(), если все элементы списка меньше указанного ключа. Обратите внимание, что это гарантирует, что возвращаемое значение будет >= 0 только тогда и только тогда, когда ключ найден.
Исключения:
ClassCastException - если список содержит элементы, которые не являются взаимосравнимыми (например, строки и целые числа), или ключ поиска не является взаимосравнимым с элементами списка.

binarySearch

public static <T> int binarySearch(List<? extends T> list,
                                   T key,
                                   Comparator<? super T> c)

Ищет указанный объект в указанном списке с помощью алгоритма бинарного поиска. Список должен быть отсортирован по возрастанию в соответствии с указанным компаратором (как методом sort(List, Comparator)) до вызова этого метода. Если он не отсортирован, результаты неопределены. Если список содержит несколько элементов, равных указанному объекту, нет гарантии, какой из них будет найден.

Этот метод работает за время log(n) для списка с «случайным доступом» (который обеспечивает доступ к позиции практически за постоянное время). Если указанный список не реализует интерфейс RandomAccess и большой, этот метод выполнит бинарный поиск на основе итератора, который выполнит O(n) обходов связей и O(log n) сравнений элементов.

Параметры типа:
T - класс объектов в списке
Параметры:
list - список для поиска.
key - ключ для поиска.
c - компаратор, по которому упорядочен список. Значение null указывает, что следует использовать естественный порядок элементов.
Возвращает:
индекс ключа поиска, если он содержится в списке; в противном случае, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в список: индекс первого элемента, большего ключа, или list.size(), если все элементы списка меньше указанного ключа. Обратите внимание, что это гарантирует, что возвращаемое значение будет >= 0 только тогда и только тогда, когда ключ найден.
Исключения:
ClassCastException - если список содержит элементы, которые не являются взаимосравнимыми с использованием указанного компаратора, или ключ поиска не является взаимосравнимым с элементами списка с использованием этого компаратора.

reverse

public static void reverse(List<?> list)

Инвертирует порядок элементов в указанном списке.

Этот метод работает за линейное время.

Параметры:
list - список, элементы которого должны быть инвертированы.
Исключения:
UnsupportedOperationException - если указанный список или его итератор не поддерживают операцию set.

shuffle

public static void shuffle(List<?> list)

Случайным образом перемешивает указанный список, используя стандартный источник случайности. Все перестановки возникают с приблизительно равной вероятностью.

Оговорка «приблизительно» используется в предшествующем описании, поскольку стандартный источник случайности является только приближенно беспристрастным источником независимо выбранных битов. Если бы это был идеальный источник случайно выбранных битов, то алгоритм выбирал бы перестановки с идеальной равномерностью.

Эта реализация проходит по списку в обратном порядке, от последнего элемента до второго, повторяя обмен случайным образом выбранного элемента в «текущую позицию». Элементы выбираются случайным образом из части списка, которая простирается от первого элемента до текущей позиции включительно.

Этот метод работает за линейное время. Если указанный список не реализует интерфейс RandomAccess и большой, эта реализация переносит указанный список в массив перед перемешиванием и переносит перемешанный массив обратно в список. Это позволяет избежать квадратичного поведения, которое возникло бы при перемешивании списка «последовательного доступа» на месте.

Параметры:
list - список для перемешивания.
Исключения:
UnsupportedOperationException - если указанный список или его итератор не поддерживают операцию set.

shuffle

public static void shuffle(List<?> list,
                           Random rnd)

Случайным образом переставляет указанный список, используя указанный источник случайности. Все перестановки происходят с одинаковой вероятностью, если источник случайности честен.

Эта реализация проходит по списку в обратном порядке, от последнего элемента до второго, повторяя обмен случайным образом выбранного элемента в «текущую позицию». Элементы выбираются случайным образом из части списка, которая простирается от первого элемента до текущей позиции включительно.

Этот метод работает за линейное время. Если указанный список не реализует интерфейс RandomAccess и большой, эта реализация переносит указанный список в массив перед перемешиванием и переносит перемешанный массив обратно в список. Это позволяет избежать квадратичного поведения, которое возникло бы при перемешивании списка «последовательного доступа» на месте.

Параметры:
list - список для перемешивания.
rnd - источник случайности для перемешивания списка.
Исключения:
UnsupportedOperationException - если указанный список или его итератор не поддерживают операцию set.

swap

public static void swap(List<?> list,
                        int i,
                        int j)

Меняет местами элементы в указанном списке в указанных позициях. (Если указанные позиции равны, вызов этого метода оставляет список без изменений.)

Параметры:
list - список, в котором нужно поменять местами элементы.
i - индекс одного элемента, подлежащего обмену.
j - индекс другого элемента, подлежащего обмену.
Исключения:
IndexOutOfBoundsException - если либо i, либо j находятся вне диапазона (i < 0 || i >= list.size() || j < 0 || j >= list.size()).
С тех пор:
1.4

fill

public static <T> void fill(List<? super T> list,
                            T obj)

Заменяет все элементы заданного списка указанным элементом.

Этот метод работает за линейное время.

Параметры типа:
T — класс объектов в списке
Параметры:
list — список, который необходимо заполнить указанным элементом.
obj — элемент, которым необходимо заполнить указанный список.
Исключения:
UnsupportedOperationException — если заданный список или его итератор списка не поддерживают операцию set.

copy

public static <T> void copy(List<? super T> dest,
                            List<? extends T> src)

Копирует все элементы из одного списка в другой. После операции индекс каждого скопированного элемента в целевом списке будет идентичен его индексу в исходном списке. Размер целевого списка должен быть больше или равен размеру исходного списка. Если он больше, оставшиеся элементы в целевом списке не затрагиваются.

Этот метод работает за линейное время.

Параметры типа:
T — класс объектов в списках
Параметры:
dest — целевой список.
src — исходный список.
Исключения:
IndexOutOfBoundsException — если целевой список слишком мал, чтобы содержать весь исходный список.
UnsupportedOperationException — если итератор списка целевого списка не поддерживает операцию set.

min

public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)

Возвращает минимальный элемент данного набора, согласно естественному порядку его элементов. Все элементы в наборе должны реализовывать интерфейс Comparable. Кроме того, все элементы в наборе должны быть взаимно сравнимы (то есть, e1.compareTo(e2) не должен выбрасывать исключение ClassCastException для любых элементов e1 и e2 в наборе).

Этот метод итерируется по всему набору, поэтому он требует времени, пропорционального размеру набора.

Параметры типа:
T — класс объектов в наборе
Параметры:
coll — набор, минимальный элемент которого требуется определить.
Возвращает:
минимальный элемент данного набора, согласно естественному порядку его элементов.
Исключения:
ClassCastException — если набор содержит элементы, которые не являются взаимно сравнимыми (например, строки и целые числа).
NoSuchElementException — если набор пуст.
См. также:
Comparable

min

public static <T> T min(Collection<? extends T> coll,
                        Comparator<? super T> comp)

Возвращает минимальный элемент данного набора, согласно порядку, заданному указанным компаратором. Все элементы в наборе должны быть взаимно сравнимы указанным компаратором (то есть, comp.compare(e1, e2) не должен выбрасывать исключение ClassCastException для любых элементов e1 и e2 в наборе).

Этот метод итерируется по всему набору, поэтому он требует времени, пропорционального размеру набора.

Параметры типа:
T — класс объектов в наборе
Параметры:
coll — набор, минимальный элемент которого требуется определить.
comp — компаратор, с помощью которого определяется минимальный элемент. Значение null указывает, что следует использовать естественный порядок элементов.
Возвращает:
минимальный элемент данного набора, согласно указанному компаратору.
Исключения:
ClassCastException — если набор содержит элементы, которые не являются взаимно сравнимыми с помощью указанного компаратора.
NoSuchElementException — если набор пуст.
См. также:
Comparable

max

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)

Возвращает максимальный элемент данного набора, согласно естественному порядку его элементов. Все элементы в наборе должны реализовывать интерфейс Comparable. Кроме того, все элементы в наборе должны быть взаимно сравнимы (то есть, e1.compareTo(e2) не должен выбрасывать исключение ClassCastException для любых элементов e1 и e2 в наборе).

Этот метод итерируется по всему набору, поэтому он требует времени, пропорционального размеру набора.

Параметры типа:
T — класс объектов в наборе
Параметры:
coll — набор, максимальный элемент которого требуется определить.
Возвращает:
максимальный элемент данного набора, согласно естественному порядку его элементов.
Исключения:
ClassCastException — если набор содержит элементы, которые не являются взаимно сравнимыми (например, строки и целые числа).
NoSuchElementException — если набор пуст.
См. также:
Comparable

max

public static <T> T max(Collection<? extends T> coll,
                        Comparator<? super T> comp)

Возвращает максимальный элемент данного набора, согласно порядку, заданному указанным компаратором. Все элементы в наборе должны быть взаимно сравнимы указанным компаратором (то есть, comp.compare(e1, e2) не должен выбрасывать исключение ClassCastException для любых элементов e1 и e2 в наборе).

Этот метод итерируется по всему набору, поэтому он требует времени, пропорционального размеру набора.

Параметры типа:
T — класс объектов в наборе
Параметры:
coll — набор, максимальный элемент которого требуется определить.
comp — компаратор, с помощью которого определяется максимальный элемент. Значение null указывает, что следует использовать естественный порядок элементов.
Возвращает:
максимальный элемент данного набора, согласно указанному компаратору.
Исключения:
ClassCastException — если набор содержит элементы, которые не являются взаимно сравнимыми с помощью указанного компаратора.
NoSuchElementException — если набор пуст.
См. также:
Comparable

rotate

public static void rotate(List<?> list,
                          int distance)

Поворачивает элементы в указанном списке на заданное расстояние. После вызова этого метода элемент с индексом i будет элементом, который ранее находился с индексом (i - distance) по модулю list.size(), для всех значений i от 0 до list.size()-1 включительно. (Этот метод не влияет на размер списка.)

Например, предположим, что list содержит [t, a, n, k, s]. После вызова Collections.rotate(list, 1) (или Collections.rotate(list, -4)), list будет содержать [s, t, a, n, k].

Обратите внимание, что этот метод может быть полезен для применения к подспискам для перемещения одного или нескольких элементов внутри списка, сохраняя порядок оставшихся элементов. Например, следующий фрагмент кода перемещает элемент с индексом j вперёд к позиции k (которая должна быть больше или равна j):

Collections.rotate(list.subList(j, k+1), -1);
Чтобы сделать это конкретным, предположим, что list содержит [a, b, c, d, e]. Чтобы переместить элемент с индексом 1 (b) вперёд на две позиции, выполните следующий вызов: 
Collections.rotate(l.subList(1, 4), -1);
Результирующий список — [a, c, d, b, e].

Чтобы переместить более одного элемента вперёд, увеличьте абсолютное значение расстояния поворота. Чтобы переместить элементы назад, используйте положительное смещение.

Если указанный список небольшой или реализует интерфейс RandomAccess, эта реализация меняет первый элемент на нужное место, а затем повторяет обмен смещённого элемента на нужное место до тех пор, пока смещённый элемент не поменяется местами с первым элементом. При необходимости процесс повторяется для второго и последующих элементов, пока поворот не будет завершён. Если указанный список большой и не реализует интерфейс RandomAccess, эта реализация разбивает список на два подсписка вокруг индекса -distance mod size. Затем метод reverse(List) вызывается для каждого подсписка, а затем для всего списка. Более подробное описание обоих алгоритмов см. в разделе 2.3 книги Джона Бентли «Programming Pearls» (Addison-Wesley, 1986).

Параметры:
list — список, который необходимо повернуть.
distance — расстояние поворота списка. Нет ограничений на это значение; оно может быть нулевым, отрицательным или больше, чем list.size().
Исключения:
UnsupportedOperationException — если указанный список или его итератор списка не поддерживает операцию set.
С момента:
1.4

replaceAll

public static <T> boolean replaceAll(List<T> list,
                                     T oldVal,
                                     T newVal)

Заменяет все вхождения одного заданного значения в списке другим. Более формально, заменяет newVal каждый элемент e в list таком, что (oldVal==null ? e==null : oldVal.equals(e)). (Этот метод не влияет на размер списка.)

Параметры типа:
T — класс объектов в списке
Параметры:
list — список, в котором должна произойти замена.
oldVal — старое значение, которое нужно заменить.
newVal — новое значение, которым нужно заменить oldVal.
Возвращает:
true, если list содержал один или несколько элементов e, таких, что (oldVal==null ? e==null : oldVal.equals(e)).
Исключения:
UnsupportedOperationException — если указанный список или его итератор списка не поддерживает операцию set.
С момента:
1.4

indexOfSubList

public static int indexOfSubList(List<?> source,
                                 List<?> target)

Возвращает начальную позицию первого вхождения указанного целевого списка в указанный исходный список или -1, если такого вхождения нет. Более формально, возвращает наименьший индекс i такой, что source.subList(i, i+target.size()).equals(target), или -1, если такого индекса нет. (Возвращает -1, если target.size() > source.size())

Эта реализация использует метод «грубой силы», сканируя исходный список в поисках совпадения с целевым списком в каждом местоположении.

Параметры:
source - список, в котором нужно искать первое вхождение target.
target - список, который нужно искать как подсписок source.
Возвращает:
начальную позицию первого вхождения указанного целевого списка в указанный исходный список или -1, если такого вхождения нет.
С версии:
1.4

lastIndexOfSubList

public static int lastIndexOfSubList(List<?> source,
                                     List<?> target)

Возвращает начальную позицию последнего вхождения указанного целевого списка в указанный исходный список или -1, если такого вхождения нет. Более формально, возвращает наибольший индекс i такой, что source.subList(i, i+target.size()).equals(target), или -1, если такого индекса нет. (Возвращает -1, если target.size() > source.size())

Эта реализация использует метод «грубой силы», итерируя исходный список в поисках совпадения с целевым списком в каждом местоположении.

Параметры:
source - список, в котором нужно искать последнее вхождение target.
target - список, который нужно искать как подсписок source.
Возвращает:
начальную позицию последнего вхождения указанного целевого списка в указанный исходный список или -1, если такого вхождения нет.
С версии:
1.4

unmodifiableCollection

public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c)

Возвращает неизменяемый вид указанной коллекции. Операции запроса к возвращаемой коллекции «прочитываются» из указанной коллекции, а попытки изменить возвращаемую коллекцию, как напрямую, так и через её итератор, приводят к UnsupportedOperationException.

Возвращаемая коллекция не передает операции hashCode и equals базовой коллекции, а полагается на методы Object's equals и hashCode. Это необходимо для сохранения контрактов этих операций в случае, если базовая коллекция является множеством или списком.

Возвращаемая коллекция будет сериализуемой, если указанная коллекция сериализуема.

Параметры типа:
T - класс объектов в коллекции
Параметры:
c - коллекция, для которой нужно вернуть неизменяемый вид.
Возвращает:
неизменяемый вид указанной коллекции.

unmodifiableSet

public static <T> Set<T> unmodifiableSet(Set<? extends T> s)

Возвращает неизменяемый вид указанного множества. Операции запроса к возвращаемому множеству «прочитываются» из указанного множества, а попытки изменить возвращаемое множество, как напрямую, так и через его итератор, приводят к UnsupportedOperationException.

Возвращаемое множество будет сериализуемым, если указанное множество сериализуемо.

Параметры типа:
T - класс объектов в множестве
Параметры:
s - множество, для которого нужно вернуть неизменяемый вид.
Возвращает:
неизменяемый вид указанного множества.

unmodifiableSortedSet

public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)

Возвращает неизменяемый вид указанного отсортированного множества. Операции запроса к возвращаемому отсортированному множеству «прочитываются» из указанного отсортированного множества. Попытки изменить возвращаемое отсортированное множество, как напрямую, через его итератор, так и через его представления subSet, headSet или tailSet, приводят к UnsupportedOperationException.

Возвращаемое отсортированное множество будет сериализуемым, если указанное отсортированное множество сериализуемо.

Параметры типа:
T - класс объектов в множестве
Параметры:
s - отсортированное множество, для которого нужно вернуть неизменяемый вид.
Возвращает:
неизменяемый вид указанного отсортированного множества.

unmodifiableNavigableSet

public static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s)

Возвращает неизменяемый вид указанного навигационного множества. Операции запроса к возвращаемому навигационному множеству «прочитываются» из указанного навигационного множества. Попытки изменить возвращаемое навигационное множество, как напрямую, через его итератор, так и через его представления subSet, headSet или tailSet, приводят к UnsupportedOperationException.

Возвращаемое навигационное множество будет сериализуемым, если указанное навигационное множество сериализуемо.

Параметры типа:
T - класс объектов в множестве
Параметры:
s - навигационное множество, для которого нужно вернуть неизменяемый вид
Возвращает:
неизменяемый вид указанного навигационного множества
С версии:
1.8

unmodifiableList

public static <T> List<T> unmodifiableList(List<? extends T> list)

Возвращает неизменяемый вид указанного списка. Операции запроса к возвращаемому списку «прочитываются» из указанного списка, а попытки изменить возвращаемый список, как напрямую, так и через его итератор, приводят к UnsupportedOperationException.

Возвращаемый список будет сериализуемым, если указанный список сериализуем. Аналогично, возвращаемый список будет реализовывать RandomAccess, если указанный список это делает.

Параметры типа:
T - класс объектов в списке
Параметры:
list - список, для которого нужно вернуть неизменяемый вид.
Возвращает:
неизменяемый вид указанного списка.

unmodifiableMap

public static <K,V> Map<K,​V> unmodifiableMap​(Map<? extends K,​? extends V> m)

Возвращает неизменяемый вид указанной карты. Операции запроса к возвращаемой карте «прочитываются» из указанной карты, а попытки изменить возвращаемую карту, как напрямую, так и через её представления коллекций, приводят к UnsupportedOperationException.

Возвращаемая карта будет сериализуемой, если указанная карта сериализуема.

Параметры типа:
K - класс ключей карты
V - класс значений карты
Параметры:
m - карта, для которой нужно вернуть неизменяемый вид.
Возвращает:
неизменяемый вид указанной карты.

unmodifiableSortedMap

public static <K,V> SortedMap<K,​V> unmodifiableSortedMap​(SortedMap<K,​? extends V> m)

Возвращает неизменяемый вид указанной отсортированной карты. Операции запроса к возвращаемой отсортированной карте «прочитываются» из указанной отсортированной карты. Попытки изменить возвращаемую отсортированную карту, как напрямую, через её представления коллекций, так и через её представления subMap, headMap или tailMap, приводят к UnsupportedOperationException.

Возвращаемая отсортированная карта будет сериализуемой, если указанная отсортированная карта сериализуема.

Параметры типа:
K - класс ключей карты
V - класс значений карты
Параметры:
m - отсортированная карта, для которой нужно вернуть неизменяемый вид.
Возвращает:
неизменяемый вид указанной отсортированной карты.

unmodifiableNavigableMap

public static <K,V> NavigableMap<K,​V> unmodifiableNavigableMap​(NavigableMap<K,​? extends V> m)

Возвращает неизменяемый вид указанной навигационной карты. Операции запроса к возвращаемой навигационной карте «прочитываются» из указанной навигационной карты. Попытки изменить возвращаемую навигационную карту, как напрямую, через её представления коллекций, так и через её представления subMap, headMap или tailMap, приводят к UnsupportedOperationException.

Возвращаемая навигационная карта будет сериализуемой, если указанная навигационная карта сериализуема.

Параметры типа:
K - класс ключей карты
V - класс значений карты
Параметры:
m - навигационная карта, для которой нужно вернуть неизменяемый вид
Возвращает:
неизменяемый вид указанной навигационной карты
С версии:
1.8

synchronizedCollection

public static <T> Collection<T> synchronizedCollection(Collection<T> c)

Возвращает синхронизированную (потокобезопасную) коллекцию, поддерживаемую указанной коллекцией. Для гарантированного последовательного доступа крайне важно, чтобы весь доступ к базовой коллекции осуществлялся через возвращаемую коллекцию.

Крайне важно, чтобы пользователь вручную синхронизировался с возвращаемой коллекцией при её проходе с помощью Iterator, Spliterator или Stream: 

Collection c = Collections.synchronizedCollection(myCollection);
     ...
  synchronized (c) {
      Iterator i = c.iterator(); // Must be in the synchronized block
      while (i.hasNext())
         foo(i.next());
  }
Несоблюдение этого совета может привести к недетерминированному поведению.

Возвращаемая коллекция не передает операции hashCode и equals базовой коллекции, а полагается на методы equals и hashCode Object. Это необходимо для сохранения контрактов этих операций в случае, если базовая коллекция является множеством или списком.

Возвращаемая коллекция будет сериализуемой, если указанная коллекция сериализуема.

Параметры типа:
T - класс объектов в коллекции
Параметры:
c - коллекция, которую нужно «завернуть» в синхронизированную коллекцию.
Возвращает:
синхронизированный вид указанной коллекции.

synchronizedSet

public static <T> Set<T> synchronizedSet(Set<T> s)

Возвращает синхронизированное (безопасное для потоков) множество, поддерживаемое указанным множеством. Для обеспечения последовательного доступа крайне важно, что все обращения к базовому множеству выполняются через возвращённое множество.

Необходимо вручную синхронизировать полученную коллекцию при её обходе с помощью Iterator, Spliterator или Stream: 

Set s = Collections.synchronizedSet(new HashSet());
      ...
  synchronized (s) {
      Iterator i = s.iterator(); // Must be in the synchronized block
      while (i.hasNext())
          foo(i.next());
  }
Несоблюдение этого совета может привести к непредсказуемому поведению.

Возвращаемое множество будет сериализуемым, если указанное множество является сериализуемым.

Параметры типа:
T - класс объектов в множестве
Параметры:
s - множество, которое будет "оборачиваться" в синхронизированное множество.
Возвращает:
синхронизированный вид указанного множества.

synchronizedSortedSet

public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)

Возвращает синхронизированное (безопасное для потоков) упорядоченное множество, поддерживаемое указанным упорядоченным множеством. Для обеспечения последовательного доступа крайне важно, что все обращения к базовому упорядоченному множеству выполняются через возвращённое упорядоченное множество (или его представления).

Необходимо вручную синхронизировать возвращённое упорядоченное множество при его обходе или любом из его subSet, headSet или tailSet представлений с помощью Iterator, Spliterator или Stream: 

SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
      ...
  synchronized (s) {
      Iterator i = s.iterator(); // Must be in the synchronized block
      while (i.hasNext())
          foo(i.next());
  }
или: 
SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
  SortedSet s2 = s.headSet(foo);
      ...
  synchronized (s) {  // Note: s, not s2!!!
      Iterator i = s2.iterator(); // Must be in the synchronized block
      while (i.hasNext())
          foo(i.next());
  }
Несоблюдение этого совета может привести к непредсказуемому поведению.

Возвращаемое упорядоченное множество будет сериализуемым, если указанное упорядоченное множество является сериализуемым.

Параметры типа:
T - класс объектов в множестве
Параметры:
s - упорядоченное множество, которое будет "оборачиваться" в синхронизированное упорядоченное множество.
Возвращает:
синхронизированный вид указанного упорядоченного множества.

synchronizedNavigableSet

public static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s)

Возвращает синхронизированное (безопасное для потоков) навигационное множество, поддерживаемое указанным навигационным множеством. Для обеспечения последовательного доступа крайне важно, что все обращения к базовому навигационному множеству выполняются через возвращённое навигационное множество (или его представления).

Необходимо вручную синхронизировать возвращённое навигационное множество при его обходе или любом из его subSet, headSet или tailSet представлений с помощью Iterator, Spliterator или Stream: 

NavigableSet s = Collections.synchronizedNavigableSet(new TreeSet());
      ...
  synchronized (s) {
      Iterator i = s.iterator(); // Must be in the synchronized block
      while (i.hasNext())
          foo(i.next());
  }
или: 
NavigableSet s = Collections.synchronizedNavigableSet(new TreeSet());
  NavigableSet s2 = s.headSet(foo, true);
      ...
  synchronized (s) {  // Note: s, not s2!!!
      Iterator i = s2.iterator(); // Must be in the synchronized block
      while (i.hasNext())
          foo(i.next());
  }
Несоблюдение этого совета может привести к непредсказуемому поведению.

Возвращаемое навигационное множество будет сериализуемым, если указанное навигационное множество является сериализуемым.

Параметры типа:
T - класс объектов в множестве
Параметры:
s - навигационное множество, которое будет "оборачиваться" в синхронизированное навигационное множество
Возвращает:
синхронизированный вид указанного навигационного множества
С:
1.8

synchronizedList

public static <T> List<T> synchronizedList(List<T> list)

Возвращает синхронизированный (безопасный для потоков) список, поддерживаемый указанным списком. Для обеспечения последовательного доступа крайне важно, что все обращения к базовому списку выполняются через возвращённый список.

Необходимо вручную синхронизировать возвращённый список при его обходе с помощью Iterator, Spliterator или Stream: 

List list = Collections.synchronizedList(new ArrayList());
      ...
  synchronized (list) {
      Iterator i = list.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }
Несоблюдение этого совета может привести к непредсказуемому поведению.

Возвращаемый список будет сериализуемым, если указанный список является сериализуемым.

Параметры типа:
T - класс объектов в списке
Параметры:
list - список, который будет "оборачиваться" в синхронизированный список.
Возвращает:
синхронизированный вид указанного списка.

synchronizedMap

public static <K,V> Map<K,​V> synchronizedMap​(Map<K,​V> m)

Возвращает синхронизированную (безопасную для потоков) карту, поддерживаемую указанной картой. Для обеспечения последовательного доступа крайне важно, что все обращения к базовой карте выполняются через возвращённую карту.

Необходимо вручную синхронизировать возвращённую карту при обходе любых её представлений коллекций с помощью Iterator, Spliterator или Stream: 

Map m = Collections.synchronizedMap(new HashMap());
      ...
  Set s = m.keySet();  // Needn't be in synchronized block
      ...
  synchronized (m) {  // Synchronizing on m, not s!
      Iterator i = s.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }
Несоблюдение этого совета может привести к непредсказуемому поведению.

Возвращаемая карта будет сериализуемой, если указанная карта является сериализуемой.

Параметры типа:
K - класс ключей карты
V - класс значений карты
Параметры:
m - карта, которая будет "оборачиваться" в синхронизированную карту.
Возвращает:
синхронизированный вид указанной карты.

synchronizedSortedMap

public static <K,V> SortedMap<K,​V> synchronizedSortedMap​(SortedMap<K,​V> m)

Возвращает синхронизированную (безопасную для потоков) упорядоченную карту, поддерживаемую указанной упорядоченной картой. Для обеспечения последовательного доступа крайне важно, что все обращения к базовой упорядоченной карте выполняются через возвращённую упорядоченную карту (или её представления).

Необходимо вручную синхронизировать возвращённую упорядоченную карту при обходе любых её представлений коллекций, или представлений коллекций любого из её subMap, headMap или tailMap представлений, с помощью Iterator, Spliterator или Stream: 

SortedMap m = Collections.synchronizedSortedMap(new TreeMap());
      ...
  Set s = m.keySet();  // Needn't be in synchronized block
      ...
  synchronized (m) {  // Synchronizing on m, not s!
      Iterator i = s.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }
или: 
SortedMap m = Collections.synchronizedSortedMap(new TreeMap());
  SortedMap m2 = m.subMap(foo, bar);
      ...
  Set s2 = m2.keySet();  // Needn't be in synchronized block
      ...
  synchronized (m) {  // Synchronizing on m, not m2 or s2!
      Iterator i = s2.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }
Несоблюдение этого совета может привести к непредсказуемому поведению.

Возвращаемая упорядоченная карта будет сериализуемой, если указанная упорядоченная карта является сериализуемой.

Параметры типа:
K - класс ключей карты
V - класс значений карты
Параметры:
m - упорядоченная карта, которая будет "оборачиваться" в синхронизированную упорядоченную карту.
Возвращает:
синхронизированный вид указанной упорядоченной карты.

synchronizedNavigableMap

public static <K,V> NavigableMap<K,​V> synchronizedNavigableMap​(NavigableMap<K,​V> m)

Возвращает синхронизированную (безопасную для потоков) навигационную карту, поддерживаемую указанной навигационной картой. Для обеспечения последовательного доступа крайне важно, что все обращения к базовой навигационной карте выполняются через возвращённую навигационную карту (или её представления).

Необходимо вручную синхронизировать возвращённую навигационную карту при обходе любых её представлений коллекций, или представлений коллекций любого из её subMap, headMap или tailMap представлений, с помощью Iterator, Spliterator или Stream: 

NavigableMap m = Collections.synchronizedNavigableMap(new TreeMap());
      ...
  Set s = m.keySet();  // Needn't be in synchronized block
      ...
  synchronized (m) {  // Synchronizing on m, not s!
      Iterator i = s.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }
или: 
NavigableMap m = Collections.synchronizedNavigableMap(new TreeMap());
  NavigableMap m2 = m.subMap(foo, true, bar, false);
      ...
  Set s2 = m2.keySet();  // Needn't be in synchronized block
      ...
  synchronized (m) {  // Synchronizing on m, not m2 or s2!
      Iterator i = s.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }
Несоблюдение этого совета может привести к непредсказуемому поведению.

Возвращаемая навигационная карта будет сериализуемой, если указанная навигационная карта является сериализуемой.

Параметры типа:
K - класс ключей карты
V - класс значений карты
Параметры:
m - навигационная карта, которая будет "оборачиваться" в синхронизированную навигационную карту
Возвращает:
синхронизированный вид указанной навигационной карты.
С:
1.8

checkedCollection

public static <E> Collection<E> checkedCollection(Collection<E> c,
                                                  Class<E> type)

Возвращает динамически типизированный вид указанной коллекции. Любая попытка вставить элемент неправильного типа приведёт к немедленному возникновению ClassCastException. Предполагая, что коллекция не содержит элементов неправильного типа до момента создания динамически типизированного представления, и что все последующие обращения к коллекции выполняются через представление, гарантируется, что коллекция не может содержать элемент неправильного типа.

Механизм дженериков языка обеспечивает проверку типов на этапе компиляции (статическую), но возможно обойти этот механизм с помощью неявных преобразований типов. Обычно это не проблема, так как компилятор выдаёт предупреждения при всех таких неявных операциях. Однако существуют случаи, когда статическая проверка типов недостаточна. Например, предположим, что коллекция передаётся сторонней библиотеке, и крайне важно, чтобы код библиотеки не повредил коллекцию, вставив элемент неправильного типа.

Другое использование динамически типизированных представлений - отладка. Предположим, что программа терпит неудачу с ClassCastException, указывая, что в параметризованную коллекцию был вставлен элемент неправильного типа. К сожалению, исключение может возникнуть в любое время после вставки ошибочного элемента, поэтому оно обычно даёт мало или совсем не даёт информации о реальном источнике проблемы. Если проблема воспроизводима, можно быстро определить её источник, временно изменив программу, чтобы обернуть коллекцию с помощью динамически типизированного представления. Например, это объявление: 

Collection<String> c = new HashSet<>();
может быть временно заменено этим: 
Collection<String> c = Collections.checkedCollection(
         new HashSet<>(), String.class);
Запуск программы снова вызовет сбой в том месте, где в коллекцию вставляется элемент неправильного типа, чётко определив источник проблемы. После исправления проблемы изменённое объявление может быть возвращено к исходному.

Возвращаемая коллекция не пропускает операции hashCode и equals в базовую коллекцию, но опирается на методы Object's equals и hashCode. Это необходимо, чтобы сохранить контракты этих операций в случае, если базовая коллекция является множеством или списком.

Возвращаемая коллекция будет сериализуемой, если указанная коллекция является сериализуемой.

Поскольку null считается значением любого ссылочного типа, возвращаемая коллекция допускает вставку нулевых элементов всякий раз, когда это делает базовая коллекция.

Параметры типа:
E — класс объектов в коллекции
Параметры:
c — коллекция, для которой требуется динамически типизированный вид
type — тип элемента, который c может содержать
Возвращает:
динамически типизированный вид указанной коллекции
С:
1.5

checkedQueue

public static <E> Queue<E> checkedQueue(Queue<E> queue,
                                        Class<E> type)

Возвращает динамически типизированный вид указанной очереди. Любая попытка вставить элемент неправильного типа приведёт к немедленному возникновению исключения ClassCastException. Предполагая, что очередь не содержит элементов неправильного типа до момента генерации динамически типизированного вида и что все последующие обращения к очереди выполняются через этот вид, гарантируется, что очередь не может содержать элемент неправильного типа.

Описание использования динамически типизированных видов можно найти в документации для метода checkedCollection.

Возвращаемая очередь будет сериализуемой, если указанная очередь сериализуема.

Поскольку null считается значением любого ссылочного типа, возвращаемая очередь допускает вставку null элементов всякий раз, когда это допускает базовая очередь.

Параметры типа:
E — класс объектов в очереди
Параметры:
queue — очередь, для которой требуется динамически типизированный вид
type — тип элемента, который queue может содержать
Возвращает:
динамически типизированный вид указанной очереди
С:
1.8

checkedSet

public static <E> Set<E> checkedSet(Set<E> s,
                                    Class<E> type)

Возвращает динамически типизированный вид указанного множества. Любая попытка вставить элемент неправильного типа приведёт к немедленному возникновению исключения ClassCastException. Предполагая, что множество не содержит элементов неправильного типа до момента генерации динамически типизированного вида и что все последующие обращения к множеству выполняются через этот вид, гарантируется, что множество не может содержать элемент неправильного типа.

Описание использования динамически типизированных видов можно найти в документации для метода checkedCollection.

Возвращаемое множество будет сериализуемым, если указанное множество сериализуемо.

Поскольку null считается значением любого ссылочного типа, возвращаемое множество допускает вставку элементов null всякий раз, когда это допускает базовое множество.

Параметры типа:
E — класс объектов в множестве
Параметры:
s — множество, для которого требуется динамически типизированный вид
type — тип элемента, который s может содержать
Возвращает:
динамически типизированный вид указанного множества
С:
1.5

checkedSortedSet

public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s,
                                                Class<E> type)

Возвращает динамически типизированный вид указанного упорядоченного множества. Любая попытка вставить элемент неправильного типа приведёт к немедленному возникновению исключения ClassCastException. Предполагая, что упорядоченное множество не содержит элементов неправильного типа до момента генерации динамически типизированного вида и что все последующие обращения к упорядоченному множеству выполняются через этот вид, гарантируется, что упорядоченное множество не может содержать элемент неправильного типа.

Описание использования динамически типизированных видов можно найти в документации для метода checkedCollection.

Возвращаемое упорядоченное множество будет сериализуемым, если указанное упорядоченное множество сериализуемо.

Поскольку null считается значением любого ссылочного типа, возвращаемое упорядоченное множество допускает вставку элементов null всякий раз, когда это допускает базовое упорядоченное множество.

Параметры типа:
E — класс объектов в множестве
Параметры:
s — упорядоченное множество, для которого требуется динамически типизированный вид
type — тип элемента, который s может содержать
Возвращает:
динамически типизированный вид указанного упорядоченного множества
С:
1.5

checkedNavigableSet

public static <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s,
                                                      Class<E> type)

Возвращает динамически типизированный вид указанного навигационного множества. Любая попытка вставить элемент неправильного типа приведёт к немедленному возникновению исключения ClassCastException. Предполагая, что навигационное множество не содержит элементов неправильного типа до момента генерации динамически типизированного вида и что все последующие обращения к навигационному множеству выполняются через этот вид, гарантируется, что навигационное множество не может содержать элемент неправильного типа.

Описание использования динамически типизированных видов можно найти в документации для метода checkedCollection.

Возвращаемое навигационное множество будет сериализуемым, если указанное навигационное множество сериализуемо.

Поскольку null считается значением любого ссылочного типа, возвращаемое навигационное множество допускает вставку элементов null всякий раз, когда это допускает базовое упорядоченное множество.

Параметры типа:
E — класс объектов в множестве
Параметры:
s — навигационное множество, для которого требуется динамически типизированный вид
type — тип элемента, который s может содержать
Возвращает:
динамически типизированный вид указанного навигационного множества
С:
1.8

checkedList

public static <E> List<E> checkedList(List<E> list,
                                      Class<E> type)

Возвращает динамически типизированный вид указанного списка. Любая попытка вставить элемент неправильного типа приведёт к немедленному возникновению исключения ClassCastException. Предполагая, что список не содержит элементов неправильного типа до момента генерации динамически типизированного вида и что все последующие обращения к списку выполняются через этот вид, гарантируется, что список не может содержать элемент неправильного типа.

Описание использования динамически типизированных видов можно найти в документации для метода checkedCollection.

Возвращаемый список будет сериализуемым, если указанный список сериализуем.

Поскольку null считается значением любого ссылочного типа, возвращаемый список допускает вставку элементов null всякий раз, когда это допускает базовый список.

Параметры типа:
E — класс объектов в списке
Параметры:
list — список, для которого требуется динамически типизированный вид
type — тип элемента, который list может содержать
Возвращает:
динамически типизированный вид указанного списка
С:
1.5

checkedMap

public static <K,V> Map<K,​V> checkedMap​(Map<K,​V> m,
                                                    Class<K> keyType,
                                                    Class<V> valueType)

Возвращает динамически типизированный вид указанной карты. Любая попытка вставить отображение, у которого ключ или значение имеют неправильный тип, приведёт к немедленному возникновению исключения ClassCastException. Аналогично, любая попытка изменить значение, связанное в данный момент с ключом, приведёт к немедленному возникновению исключения ClassCastException, независимо от того, предпринимается ли изменение непосредственно через карту или через экземпляр Map.Entry, полученный из представления entry set карты.

Предполагая, что карта не содержит ключей или значений неправильного типа до момента генерации динамически типизированного вида и что все последующие обращения к карте выполняются через этот вид (или одно из его представлений коллекций), гарантируется, что карта не может содержать неправильный тип ключа или значения.

Описание использования динамически типизированных видов можно найти в документации для метода checkedCollection.

Возвращаемая карта будет сериализуемой, если указанная карта сериализуема.

Поскольку null считается значением любого ссылочного типа, возвращаемая карта допускает вставку нулевых ключей или значений всякий раз, когда это допускает базовая карта.

Параметры типа:
K — класс ключей карты
V — класс значений карты
Параметры:
m — карта, для которой требуется динамически типизированный вид
keyType — тип ключа, который m может содержать
valueType — тип значения, который m может содержать
Возвращает:
динамически типизированный вид указанной карты
С:
1.5

checkedSortedMap

public static <K,V> SortedMap<K,​V> checkedSortedMap​(SortedMap<K,​V> m,
                                                                Class<K> keyType,
                                                                Class<V> valueType)

Возвращает динамически типизированный вид указанного отсортированного отображения. Любая попытка вставить отображение, ключ или значение которого имеют неправильный тип, приведет к немедленному исключению ClassCastException. Аналогично, любая попытка изменить значение, в настоящее время связанное с ключом, приведет к немедленному исключению ClassCastException, независимо от того, предпринимается ли изменение непосредственно через само отображение или через экземпляр Map.Entry, полученный из представления entry set отображения.

Предполагая, что отображение не содержит ключей или значений с неправильным типом до момента создания динамически типизированного вида, и что все последующие обращения к отображению выполняются через представление (или одно из его представлений коллекций), гарантируется, что отображение не может содержать ключ или значение с неправильным типом.

Обсуждение использования динамически типизированных представлений можно найти в документации для метода checkedCollection.

Возвращаемое отображение будет сериализуемым, если указанное отображение является сериализуемым.

Так как null считается значением любого ссылочного типа, возвращаемое отображение допускает вставку нулевых ключей или значений всякий раз, когда это делает базовое отображение.

Type Parameters:
K - класс ключей отображения
V - класс значений отображения
Parameters:
m - отображение, для которого необходимо вернуть динамически типизированное представление
keyType - тип ключа, который m разрешено содержать
valueType - тип значения, который m разрешено содержать
Returns:
динамически типизированное представление указанного отображения
Since:
1.5

checkedNavigableMap

public static <K,V> NavigableMap<K,​V> checkedNavigableMap​(NavigableMap<K,​V> m,
                                                                      Class<K> keyType,
                                                                      Class<V> valueType)

Возвращает динамически типизированный вид указанного отображения по принципу навигации. Любая попытка вставить отображение, ключ или значение которого имеют неправильный тип, приведет к немедленному исключению ClassCastException. Аналогично, любая попытка изменить значение, в настоящее время связанное с ключом, приведет к немедленному исключению ClassCastException, независимо от того, предпринимается ли изменение непосредственно через само отображение или через экземпляр Map.Entry, полученный из представления entry set отображения.

Предполагая, что отображение не содержит ключей или значений с неправильным типом до момента создания динамически типизированного вида, и что все последующие обращения к отображению выполняются через представление (или одно из его представлений коллекций), гарантируется, что отображение не может содержать ключ или значение с неправильным типом.

Обсуждение использования динамически типизированных представлений можно найти в документации для метода checkedCollection.

Возвращаемое отображение будет сериализуемым, если указанное отображение является сериализуемым.

Так как null считается значением любого ссылочного типа, возвращаемое отображение допускает вставку нулевых ключей или значений всякий раз, когда это делает базовое отображение.

Type Parameters:
K - тип ключей отображения
V - тип значений отображения
Parameters:
m - отображение, для которого необходимо вернуть динамически типизированное представление
keyType - тип ключа, который m разрешено содержать
valueType - тип значения, который m разрешено содержать
Returns:
динамически типизированное представление указанного отображения
Since:
1.8

emptyIterator

public static <T> Iterator<T> emptyIterator()

Возвращает итератор без элементов. Более точно,

Реализации этого метода могут, но не обязаны, возвращать один и тот же объект при нескольких вызовах.

Type Parameters:
T - тип элементов, если они были в итераторе
Returns:
пустой итератор
Since:
1.7

emptyListIterator

public static <T> ListIterator<T> emptyListIterator()

Возвращает список итератор без элементов. Более точно,

Реализации этого метода могут, но не обязаны, возвращать один и тот же объект при нескольких вызовах.

Type Parameters:
T - тип элементов, если они были в итераторе
Returns:
пустой список итератор
Since:
1.7

emptyEnumeration

public static <T> Enumeration<T> emptyEnumeration()

Возвращает перечисление без элементов. Более точно,

Реализации этого метода могут, но не обязаны, возвращать один и тот же объект при нескольких вызовах.

Type Parameters:
T - класс объектов в перечислении
Returns:
пустое перечисление
Since:
1.7

emptySet

public static final <T> Set<T> emptySet()

Возвращает пустое множество (неизменяемое). Это множество сериализуемо. В отличие от одноимённого поля, этот метод параметризован.

Этот пример демонстрирует безопасный с точки зрения типов способ получения пустого множества: 

Set<String> s = Collections.emptySet();
Implementation Note:
Реализации этого метода не обязаны создавать отдельный объект Set для каждого вызова. Использование этого метода, вероятно, будет иметь сравнимую стоимость с использованием одноимённого поля. (В отличие от этого метода, поле не обеспечивает безопасность типов.)
Type Parameters:
T - класс объектов в множестве
Returns:
пустое множество
Since:
1.5
See Also:
EMPTY_SET

emptySortedSet

public static <E> SortedSet<E> emptySortedSet()

Возвращает пустое отсортированное множество (неизменяемое). Это множество сериализуемо.

Этот пример демонстрирует безопасный с точки зрения типов способ получения пустого отсортированного множества: 

SortedSet<String> s = Collections.emptySortedSet();
Implementation Note:
Реализации этого метода не обязаны создавать отдельный объект SortedSet для каждого вызова.
Type Parameters:
E - тип элементов, если они были в множестве
Returns:
пустое отсортированное множество
Since:
1.8

emptyNavigableSet

public static <E> NavigableSet<E> emptyNavigableSet()

Возвращает пустое навигируемое множество (неизменяемое). Это множество сериализуемо.

Этот пример демонстрирует безопасный с точки зрения типов способ получения пустого навигируемого множества: 

NavigableSet<String> s = Collections.emptyNavigableSet();
Implementation Note:
Реализации этого метода не обязаны создавать отдельный объект NavigableSet для каждого вызова.
Type Parameters:
E - тип элементов, если они были в множестве
Returns:
пустое навигируемое множество
Since:
1.8

emptyList

public static final <T> List<T> emptyList()

Возвращает пустой список (неизменяемый). Этот список сериализуем.

Этот пример демонстрирует безопасный с точки зрения типов способ получения пустого списка: 

List<String> s = Collections.emptyList();
Implementation Note:
Реализации этого метода не обязаны создавать отдельный объект List для каждого вызова. Использование этого метода, вероятно, будет иметь сравнимую стоимость с использованием одноимённого поля. (В отличие от этого метода, поле не обеспечивает безопасность типов.)
Type Parameters:
T - тип элементов, если они были в списке
Returns:
пустой неизменяемый список
Since:
1.5
See Also:
EMPTY_LIST

emptyMap

public static final <K,V> Map<K,​V> emptyMap()

Возвращает пустое отображение (неизменяемое). Это отображение сериализуемо.

Этот пример демонстрирует безопасный с точки зрения типов способ получения пустого отображения: 

Map<String, Date> s = Collections.emptyMap();
Implementation Note:
Реализации этого метода не обязаны создавать отдельный объект Map для каждого вызова. Использование этого метода, вероятно, будет иметь сравнимую стоимость с использованием одноимённого поля. (В отличие от этого метода, поле не обеспечивает безопасность типов.)
Type Parameters:
K - класс ключей отображения
V - класс значений отображения
Returns:
пустое отображение
Since:
1.5
See Also:
EMPTY_MAP

emptySortedMap

public static final <K,V> SortedMap<K,​V> emptySortedMap()

Возвращает пустое отсортированное отображение (неизменяемое). Это отображение сериализуемо.

Этот пример демонстрирует безопасный с точки зрения типов способ получения пустого отображения: 

SortedMap<String, Date> s = Collections.emptySortedMap();
Implementation Note:
Реализации этого метода не обязаны создавать отдельный объект SortedMap для каждого вызова.
Type Parameters:
K - класс ключей отображения
V - класс значений отображения
Returns:
пустое отсортированное отображение
Since:
1.8

emptyNavigableMap

public static final <K,V> NavigableMap<K,​V> emptyNavigableMap()

Возвращает пустой навигационный map (неизменяемый). Этот map сериализуем.

Этот пример иллюстрирует безопасный способ получения пустого map:

NavigableMap<String, Date> s = Collections.emptyNavigableMap();
Implementation Note:
Реализации этого метода не обязательно должны создавать отдельный NavigableMap объект для каждого вызова.
Type Parameters:
K - класс ключей map
V - класс значений map
Returns:
пустой навигационный map
Since:
1.8

singleton

public static <T> Set<T> singleton(T o)

Возвращает неизменяемый set, содержащий только указанный объект. Возвращаемый set сериализуем.

Type Parameters:
T - класс объектов в set
Parameters:
o - единственный объект, который будет храниться в возвращаемом set.
Returns:
неизменяемый set, содержащий только указанный объект.

singletonList

public static <T> List<T> singletonList(T o)

Возвращает неизменяемый список, содержащий только указанный объект. Возвращаемый список сериализуем.

Type Parameters:
T - класс объектов в списке
Parameters:
o - единственный объект, который будет храниться в возвращаемом списке.
Returns:
неизменяемый список, содержащий только указанный объект.
Since:
1.3

singletonMap

public static <K,V> Map<K,​V> singletonMap​(K key,
                                                      V value)

Возвращает неизменяемый map, сопоставляющий только указанный ключ с указанным значением. Возвращаемый map сериализуем.

Type Parameters:
K - класс ключей map
V - класс значений map
Parameters:
key - единственный ключ, который будет храниться в возвращаемом map.
value - значение, которому возвращаемый map сопоставляет key.
Returns:
неизменяемый map, содержащий только указанное сопоставление ключ-значение.
Since:
1.3

nCopies

public static <T> List<T> nCopies(int n,
                                  T o)

Возвращает неизменяемый список, состоящий из n копий указанного объекта. Новый выделенный объект данных небольшой (он содержит только одну ссылку на объект данных). Этот метод полезен в сочетании с методом List.addAll для увеличения списков. Возвращаемый список сериализуем.

Type Parameters:
T - класс копируемого объекта и объектов в возвращаемом списке.
Parameters:
n - количество элементов в возвращаемом списке.
o - элемент, который будет повторяться в возвращаемом списке.
Returns:
неизменяемый список, состоящий из n копий указанного объекта.
Throws:
IllegalArgumentException - если n < 0
See Also:
List.addAll(Collection), List.addAll(int, Collection)

reverseOrder

public static <T> Comparator<T> reverseOrder()

Возвращает компаратор, который накладывает обратный порядок естественного упорядочения на коллекцию объектов, реализующих интерфейс Comparable. (Естественное упорядочение — это порядок, налагаемый собственным методом compareTo объектов.) Это позволяет использовать простой подход для сортировки (или поддержания) коллекций (или массивов) объектов, реализующих интерфейс Comparable в обратном естественном порядке. Например, предположим, что a — это массив строк. Тогда: 

Arrays.sort(a, Collections.reverseOrder());
сортирует массив в обратном лексикографическом (алфавитном) порядке.

Возвращаемый компаратор сериализуем.

Type Parameters:
T - класс объектов, сравниваемых компаратором
Returns:
Компаратор, который накладывает обратный порядок естественного упорядочения на коллекцию объектов, реализующих интерфейс Comparable.
See Also:
Comparable

reverseOrder

public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)

Возвращает компаратор, который накладывает обратный порядок указанного компаратора. Если указанный компаратор является null, этот метод эквивалентен методу reverseOrder() (другими словами, он возвращает компаратор, который накладывает обратный порядок естественного упорядочения на коллекцию объектов, реализующих интерфейс Comparable).

Возвращаемый компаратор сериализуем (при условии, что указанный компаратор также сериализуем или null).

Type Parameters:
T - класс объектов, сравниваемых компаратором
Parameters:
cmp - компаратор, порядок которого должен быть изменён в обратном направлении возвращаемым компаратором, или null
Returns:
Компаратор, который накладывает обратный порядок указанного компаратора.
Since:
1.5

enumeration

public static <T> Enumeration<T> enumeration(Collection<T> c)

Возвращает перечисление над указанной коллекцией. Это обеспечивает взаимодействие со старыми API, которые требуют перечисление в качестве входных данных.

Итератор, возвращённый в результате вызова Enumeration.asIterator(), не поддерживает удаление элементов из указанной коллекции. Это необходимо, чтобы случайно не увеличить возможности возвращённого перечисления.

Type Parameters:
T - класс объектов в коллекции
Parameters:
c - коллекция, для которой требуется перечисление.
Returns:
перечисление над указанной коллекцией.
See Also:
Enumeration

list

public static <T> ArrayList<T> list(Enumeration<T> e)

Возвращает список массивов, содержащий элементы, возвращаемые указанным перечислением в порядке их возвращения перечислением. Этот метод обеспечивает взаимодействие между старыми API, возвращающими перечисления, и новыми API, которые требуют коллекции.

Type Parameters:
T - класс объектов, возвращаемых перечислением
Parameters:
e - перечисление, предоставляющее элементы для возвращаемого списка массивов
Returns:
список массивов, содержащий элементы, возвращаемые указанным перечислением.
Since:
1.4
See Also:
Enumeration, ArrayList

frequency

public static int frequency(Collection<?> c,
                            Object o)

Возвращает количество элементов в указанной коллекции, равных указанному объекту. Более формально, возвращает количество элементов e в коллекции, таких что Objects.equals(o, e).

Parameters:
c - коллекция, в которой требуется определить частоту o
o - объект, частота которого требуется определить
Returns:
количество элементов в c, равных o
Throws:
NullPointerException - если c равно null
Since:
1.5

disjoint

public static boolean disjoint(Collection<?> c1,
                               Collection<?> c2)

Возвращает true, если две указанные коллекции не имеют общих элементов.

Следует проявлять осторожность, если этот метод используется на коллекциях, которые не соответствуют общему соглашению для Collection. Реализации могут выбрать итерацию по любой коллекции и проверку на включение в другую коллекцию (или выполнение любого эквивалентного вычисления). Если любая коллекция использует нестандартное сравнение на равенство (как в SortedSet, чьё упорядочение не совместимо с equals, или в наборе ключей IdentityHashMap), обе коллекции должны использовать то же нестандартное сравнение на равенство, в противном случае результат этого метода не определён.

Следует также проявлять осторожность при использовании коллекций, которые имеют ограничения на содержащиеся элементы. Реализации коллекций могут выбрасывать исключения для любой операции, связанной с элементами, которые они считают непригодными. Для абсолютной безопасности указанные коллекции должны содержать только элементы, которые являются допустимыми элементами для обеих коллекций.

Обратите внимание, что разрешается передавать одну и ту же коллекцию в обоих параметрах, в этом случае метод вернёт true только в том случае, если коллекция пуста.

Parameters:
c1 - коллекция
c2 - коллекция
Returns:
true, если две указанные коллекции не имеют общих элементов.
Throws:
NullPointerException - если любая коллекция является null.
NullPointerException - если одна коллекция содержит элемент, который является непригодным для другой коллекции. (необязательно)
ClassCastException - если одна коллекция содержит элемент типа, который непригоден для другой коллекции. (необязательно)
Since:
1.5

addAll

@SafeVarargs
public static <T> boolean addAll(Collection<? super T> c,
                                 T... elements)

Добавляет все указанные элементы в указанную коллекцию. Добавленные элементы можно указать по отдельности или в виде массива. Поведение этого удобного метода идентично поведению c.addAll(Arrays.asList(elements)), но этот метод, скорее всего, будет работать значительно быстрее в большинстве реализаций.

При указании элементов по отдельности, этот метод предоставляет удобный способ добавления нескольких элементов в существующую коллекцию:

Collections.addAll(flavors, "Peaches 'n Plutonium", "Rocky Racoon");
Параметры типа:
T — класс элементов для добавления и коллекции
Параметры:
c — коллекция, в которую будут вставлены elements
elements — элементы для вставки в c
Возвращает:
true, если коллекция изменилась в результате вызова
Выбрасывает:
UnsupportedOperationException — если c не поддерживает операцию add
NullPointerException — если elements содержит один или несколько нулевых значений, а c не допускает нулевых элементов, или если c или elements являются null
IllegalArgumentException — если какое-либо свойство значения в elements препятствует его добавлению в c
С:
1.5
См. также:
Collection.addAll(Collection)

newSetFromMap

public static <E> Set<E> newSetFromMap(Map<E,​Boolean> map)

Возвращает множество, поддерживаемое указанной картой. Возвращаемое множество отображает те же характеристики упорядочивания, конкурентности и производительности, что и базовая карта. По существу, этот фабричный метод предоставляет реализацию Set, соответствующую любой реализации Map. Нет необходимости использовать этот метод для реализации Map, которая уже имеет соответствующую реализацию Set (такую как HashMap или TreeMap).

Каждый вызов метода на множестве, возвращаемом этим методом, приводит к ровно одному вызову метода на базовой карте или её keySet представлении, за исключением одного случая. Метод addAll реализован как последовательность вызовов put на базовой карте.

Указанная карта должна быть пустой в момент вызова этого метода и не должна напрямую обращаться к ней после возврата этого метода. Эти условия обеспечиваются, если карта создана пустой, передана непосредственно в этот метод и на неё не сохраняется ссылка, как показано в следующем фрагменте кода: 

Set<Object> weakHashSet = Collections.newSetFromMap(
        new WeakHashMap<Object, Boolean>());
Параметры типа:
E — класс ключей карты и объектов в возвращаемом множестве
Параметры:
map — базовая карта
Возвращает:
множество, поддерживаемое картой
Выбрасывает:
IllegalArgumentException — если map не пуста
С:
1.6

asLifoQueue

public static <T> Queue<T> asLifoQueue(Deque<T> deque)

Возвращает представление Deque в виде очереди «последний вошёл — первый вышел» (Lifo) Queue. Метод add сопоставлен с push, remove — с pop и так далее. Это представление может быть полезно, когда требуется метод, требующий Queue, но необходимо упорядочение «последний вошёл — первый вышел».

Каждый вызов метода на очереди, возвращаемой этим методом, приводит к ровно одному вызову метода на базовом массиве дек, за исключением одного случая. Метод addAll реализован как последовательность вызовов addFirst на базовом массиве дек.

Параметры типа:
T — класс объектов в массиве дек
Параметры:
deque — массив дек
Возвращает:
очередь
С:
1.6

© 1993, 2020, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collections.html

Spec-Zone .ru
спецификации, руководства, описания, API