Класс Collections

java.lang.Object

java.util.Collections

public class Collections extends Object

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

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

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

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

Этот класс является частью Java коллекции.

С момента:

1.2

См. также:

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

Модификатор и тип	Поле	Описание
`static final List`	`EMPTY_LIST`	Пустой список (неизменяемый).
`static final Map`	`EMPTY_MAP`	Пустая карта (неизменяемая).
`static final 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 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)`	Возвращает количество элементов в указанной коллекции, равных заданному объекту.
`static int`	`indexOfSubList(List<?> source, List<?> target)`	Возвращает начальную позицию первого вхождения указанного целевого списка в указанный исходный список, или -1, если такого вхождения нет.
`static int`	`lastIndexOfSubList(List<?> source, List<?> target)`	Возвращает начальную позицию последнего вхождения указанного целевого списка в указанный исходный список, или -1, если такого вхождения нет.
`static <T> ArrayList<T>`	`list(Enumeration<T> e)`	Возвращает список ArrayList, содержащий элементы, возвращаемые указанным перечислением в порядке их возврата перечислением.
`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> 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()`	Возвращает компаратор, который накладывает обратный естественный порядок на коллекцию объектов, реализующих интерфейс `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 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)`	Возвращает неизменяемый вид указанного навигационного множества.
`static <T> SequencedCollection<T>`	`unmodifiableSequencedCollection(SequencedCollection<? extends T> c)`	Возвращает неизменяемый вид указанного `SequencedCollection`.
`static <K,V> SequencedMap<K,V>`	`unmodifiableSequencedMap(SequencedMap<? extends K, ? extends V> m)`	Возвращает неизменяемый вид указанного `SequencedMap`.
`static <T> SequencedSet<T>`	`unmodifiableSequencedSet(SequencedSet<? extends T> s)`	Возвращает неизменяемый вид указанного `SequencedSet`.
`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

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

См. также:

EMPTY_LIST

public static final List EMPTY_LIST

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

См. также:

EMPTY_MAP

public static final Map EMPTY_MAP

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

С момента:

1.3

См. также:

Подробное описание методов

sort

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

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

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

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

Примечание об реализации:

Эта реализация делегирует метод sort с использованием указанного списка и компаратора null.

Параметры типа:

T - класс объектов в списке

Параметры:

list - сортируемый список.

Исключения:

ClassCastException - если список содержит элементы, которые не являются взаимно сравнимыми (например, строки и целые числа).

UnsupportedOperationException - если итератор списка указанного списка не поддерживает операцию set.

IllegalArgumentException - (необязательно) если реализация обнаруживает, что естественный порядок элементов списка нарушает контракт Comparable

См. также:

sort

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

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

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

Примечание об реализации:

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

Параметры типа:

T - класс объектов в списке

Параметры:

list - сортируемый список.

c - компаратор для определения порядка списка. Значение null указывает, что должен использоваться естественный порядок элементов.

Исключения:

ClassCastException - если список содержит элементы, которые не являются взаимно сравнимыми с использованием указанного компаратора.

UnsupportedOperationException - если итератор указанного списка не поддерживает операцию set.

IllegalArgumentException - (необязательно) если компаратор нарушает контракт Comparator

См. также:

binarySearch

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

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

Этот метод работает за время 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), перед вызовом этого метода. Если он не отсортирован, результаты не определены. Если список содержит несколько элементов, равных указанному объекту, нет гарантии, какой из них будет найден.

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

reverse

public static void reverse(List<?> list)

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

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

Примечание API:

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

Параметры:

list - список, элементы которого необходимо инвертировать.

Исключения:

UnsupportedOperationException - если указанный список или его итератор не поддерживает операцию set.

См. также:

перемешать

public static void shuffle(List<?> list)

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

Квази-описание использует "приблизительно", потому что по умолчанию источник случайности — лишь приблизительно беспристрастный источник независимо выбранных бит. Если бы это был идеальный источник случайных бит, то алгоритм выбирал бы перестановки с идеальной равномерностью.

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

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

перемешать

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

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

Этот метод эквивалентен shuffle(List, RandomGenerator) и существует для обратной совместимости. Метод shuffle(List, RandomGenerator) предпочтительнее, так как он не ограничен генераторами случайных чисел, которые расширяют класс Random.

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

перемешать

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

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

Требования к реализации:: Этот метод выполняется за линейное время. Если указанный список не реализует интерфейс RandomAccess и является большим, эта реализация помещает указанный список в массив перед перемешиванием и помещает перемешанный массив обратно в список. Это позволяет избежать квадратичного поведения, которое возникло бы при перемешивании списка с "последовательным доступом" на месте.
Параметры:: list - список, который нужно перемешать.; rnd - источник случайности, который нужно использовать для перемешивания списка.
Исключения:: UnsupportedOperationException - если указанный список или его итератор списка не поддерживают операцию set.
С:: 21

поменять местами

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

заполнить

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

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

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

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

скопировать

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 - если набор пуст.

См. также:

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 - если набор пуст.

См. также:

max

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

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

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

Type Parameters:

T - класс объектов в наборе

Parameters:

coll - набор, максимальный элемент которого необходимо определить.

Returns:

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

Throws:

ClassCastException - если набор содержит элементы, которые не являются взаимно сравнимыми (например, строки и целые числа).

NoSuchElementException - если набор пустой.

See Also:

max

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

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

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

Type Parameters:

T - класс объектов в наборе

Parameters:

coll - набор, максимальный элемент которого необходимо определить.

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

Returns:

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

Throws:

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

NoSuchElementException - если набор пустой.

See Also:

rotate

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

Поворачивает элементы в заданном списке на указанное расстояние. После вызова этого метода элемент с индексом i будет элементом, который ранее находился на индексе (i - distance) mod 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 книги Джона Бенсли «Программистские жемчужины» (Addison-Wesley, 1986).

Parameters:: list - список, который необходимо повернуть.; distance - расстояние поворота списка. Нет ограничений на это значение; оно может быть нулевым, отрицательным или больше list.size().
Throws:: UnsupportedOperationException - если указанный список или его итератор списка не поддерживает операцию set.
Since:: 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)). (Этот метод не влияет на размер списка.)

Type Parameters:: T - класс объектов в списке
Parameters:: list - список, в котором должна произойти замена.; oldVal - старое значение, которое должно быть заменено.; newVal - новое значение, которое должно заменить oldVal.
Returns:: true если list содержал один или несколько элементов e, такие что (oldVal==null ? e==null : oldVal.equals(e)).
Throws:: UnsupportedOperationException - если указанный список или его итератор списка не поддерживают операцию set.
Since:: 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())

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

Parameters:: source - список, в котором нужно искать первое вхождение target.; target - список, который необходимо искать как подсписок source.
Returns:: начальная позиция первого вхождения указанного целевого списка в указанный исходный список или -1, если такого вхождения нет.
Since:: 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())

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

Parameters:: source - список, в котором нужно искать последнее вхождение target.; target - список, который необходимо искать как подсписок source.
Returns:: начальная позиция последнего вхождения указанного целевого списка в указанный исходный список или -1, если такого вхождения нет.
Since:: 1.4

unmodifiableCollection

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

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

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

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

Implementation Note:: Этот метод может вернуть свой аргумент, если аргумент уже неизменяемый.
Type Parameters:: T - класс объектов в наборе
Parameters:: c - набор, для которого требуется получить неизменяемый вид.
Returns:: неизменяемый вид заданного набора.

unmodifiableSequencedCollection

public static <T> SequencedCollection<T> unmodifiableSequencedCollection(SequencedCollection<? extends T> c)

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

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

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

Implementation Note:: Этот метод может вернуть свой аргумент, если аргумент уже неизменяемый.
Type Parameters:: T - класс объектов в наборе
Parameters:: c - набор, для которого требуется вернуть неизменяемый вид.
Returns:: неизменяемый вид указанного набора.
Since:: 21

unmodifiableSet

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

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

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

Implementation Note:: Этот метод может вернуть свой аргумент, если аргумент уже неизменяемый.
Type Parameters:: T - класс объектов в наборе
Parameters:: s - набор, для которого требуется вернуть неизменяемый вид.
Returns:: неизменяемый вид указанного набора.

unmodifiableSequencedSet

public static <T> SequencedSet<T> unmodifiableSequencedSet(SequencedSet<? extends T> s)

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

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

Implementation Note:: Этот метод может вернуть свой аргумент, если аргумент уже неизменяемый.
Type Parameters:: T - класс объектов в наборе
Parameters:: s - набор, для которого требуется вернуть неизменяемый вид.
Returns:: неизменяемый вид указанного упорядоченного набора.
Since:: 21

unmodifiableSortedSet

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

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

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

Implementation Note:: Этот метод может вернуть свой аргумент, если аргумент уже неизменяемый.
Type Parameters:: T - класс объектов в наборе
Parameters:: s - упорядоченный набор, для которого требуется вернуть неизменяемый вид.
Returns:: неизменяемый вид указанного упорядоченного набора.

unmodifiableNavigableSet

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

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

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

Implementation Note:: Этот метод может вернуть свой аргумент, если аргумент уже неизменяемый.
Type Parameters:: T - класс объектов в наборе
Parameters:: s - набор, для которого требуется вернуть неизменяемый вид
Returns:: неизменяемый вид указанного набора
Since:: 1.8

unmodifiableList

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

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

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

Implementation Note:: Этот метод может вернуть свой аргумент, если аргумент уже неизменяемый.
Type Parameters:: T - класс объектов в списке
Parameters:: list - список, для которого требуется вернуть неизменяемый вид.
Returns:: неизменяемый вид указанного списка.

unmodifiableMap

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

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

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

Implementation Note:: Этот метод может вернуть свой аргумент, если аргумент уже неизменяемый.
Type Parameters:: K - класс ключей карты; V - класс значений карты
Parameters:: m - карта, для которой требуется вернуть неизменяемый вид.
Returns:: неизменяемый вид указанной карты.

unmodifiableSequencedMap

public static <K,V> SequencedMap<K,V> unmodifiableSequencedMap(SequencedMap<? extends K, ? extends V> m)

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

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

Implementation Note:: Этот метод может вернуть свой аргумент, если аргумент уже неизменяемый.
Type Parameters:: K - класс ключей карты; V - класс значений карты
Parameters:: m - карта, для которой требуется вернуть неизменяемый вид.
Returns:: неизменяемый вид указанной карты.
Since:: 21

unmodifiableSortedMap

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

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

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

Implementation Note:: Этот метод может вернуть свой аргумент, если аргумент уже неизменяемый.
Type Parameters:: K - класс ключей карты; V - класс значений карты
Parameters:: m - упорядоченная карта, для которой требуется вернуть неизменяемый вид.
Returns:: неизменяемый вид указанной упорядоченной карты.

unmodifiableNavigableMap

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

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

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

Implementation Note:: Этот метод может вернуть свой аргумент, если аргумент уже неизменяемый.
Type Parameters:: K - класс ключей отображения; V - класс значений отображения
Parameters:: m - навигационное отображение, для которого требуется вернуть неизменяемый вид
Returns:: неизменяемый вид указанного навигационного отображения
Since:: 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. Это необходимо для сохранения контрактов этих операций в случае, если базовая коллекция является множеством или списком.

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

Type Parameters:: T - класс объектов в коллекции
Parameters:: c - коллекция, которая будет "обёрнута" в синхронизированную коллекцию.
Returns:: синхронизированный вид указанной коллекции.

synchronizedSet

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

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

  Set s = Collections.synchronizedSet(new HashSet());
      ...
  synchronized (s) {
      Iterator i = s.iterator(); // Must be in the synchronized block
      while (i.hasNext())
          foo(i.next());
  }

Несоблюдение этого совета может привести к непредсказуемому поведению.

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

Type Parameters:: T - класс объектов в множестве
Parameters:: s - множество, которое будет "обёрнуто" в синхронизированное множество.
Returns:: синхронизированный вид указанного множества.

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());
  }

Несоблюдение этого совета может привести к непредсказуемому поведению.

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

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

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());
  }

Несоблюдение этого совета может привести к непредсказуемому поведению.

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

Type Parameters:: T - класс объектов в множестве
Parameters:: s - навигационное множество, которое будет "обёрнуто" в синхронизированное навигационное множество
Returns:: синхронизированный вид указанного навигационного множества
Since:: 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());
  }

Несоблюдение этого совета может привести к непредсказуемому поведению.

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

Type Parameters:: T - класс объектов в списке
Parameters:: list - список, который будет "обёрнут" в синхронизированный список.
Returns:: синхронизированный вид указанного списка.

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());
  }

Несоблюдение этого совета может привести к непредсказуемому поведению.

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

Type Parameters:: K - класс ключей карты; V - класс значений карты
Parameters:: m - карта, которая будет "обёрнута" в синхронизированную карту.
Returns:: синхронизированный вид указанной карты.

синхронизированныйSortedMap

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());
  }

Несоблюдение этого совета может привести к непредсказуемому поведению.

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

Type Parameters:: K - класс ключей карты; V - класс значений карты
Parameters:: m - сортированная карта, которая должна быть "обернута" в синхронизированную сортированную карту.
Returns:: синхронизированный вид указанной сортированной карты.

синхронизированныйNavigableMap

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 = s2.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }

Несоблюдение этого совета может привести к непредсказуемому поведению.

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

Type Parameters:: K - класс ключей карты; V - класс значений карты
Parameters:: m - карта навигации, которая должна быть "обернута" в синхронизированную карту навигации
Returns:: синхронизированный вид указанной карты навигации.
Since:: 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 считается значением любого ссылочного типа, возвращаемая коллекция допускает вставку элементов null всякий раз, когда это делает базовая коллекция.

Type Parameters:: E - класс объектов в коллекции
Parameters:: c - коллекция, для которой требуется вернуть динамически безопасный вид; type - тип элемента, который c разрешено хранить
Returns:: динамически безопасный вид указанной коллекции
Since:: 1.5

checkedQueue

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

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

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

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

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

Type Parameters:: E - класс объектов в очереди
Parameters:: queue - очередь, для которой требуется вернуть динамически безопасный вид; type - тип элемента, который queue разрешено хранить
Returns:: динамически безопасный вид указанной очереди
Since:: 1.8

checkedSet

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

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

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

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

Type Parameters:: E - класс объектов в множестве
Parameters:: s - множество, для которого требуется вернуть динамически безопасный вид; type - тип элемента, который s разрешено хранить
Returns:: динамически безопасный вид указанного множества
Since:: 1.5

checkedSortedSet

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

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

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

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

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

Type Parameters:: E - класс объектов в наборе
Parameters:: s - упорядоченный набор, для которого требуется динамически типизированный вид; type - тип элемента, который s разрешено содержать
Returns:: динамически типизированный вид указанного упорядоченного набора
Since:: 1.5

checkedNavigableSet

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

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

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

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

Type Parameters:: E - класс объектов в наборе
Parameters:: s - навигационный набор, для которого требуется динамически типизированный вид; type - тип элемента, который s разрешено содержать
Returns:: динамически типизированный вид указанного навигационного набора
Since:: 1.8

checkedList

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

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

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

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

Type Parameters:: E - класс объектов в списке
Parameters:: list - список, для которого требуется динамически типизированный вид; type - тип элемента, который list разрешено содержать
Returns:: динамически типизированный вид указанного списка
Since:: 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 карты.

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

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

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

Type Parameters:: K - класс ключей карты; V - класс значений карты
Parameters:: m - карта, для которой требуется динамически типизированный вид; keyType - тип ключа, который m разрешено содержать; valueType - тип значения, который m разрешено содержать
Returns:: динамически типизированный вид указанной карты
Since:: 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 карты.

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

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

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

emptyIterator

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

Возвращает итератор, не содержащий элементов. Точнее,

hasNext всегда возвращает false.
next всегда вызывает NoSuchElementException.
remove всегда вызывает IllegalStateException.

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

Параметры типа:: T - тип элементов, если бы они были, в итераторе
Возвращает:: пустой итератор
С версии:: 1.7

emptyListIterator

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

Возвращает итератор списка, не содержащий элементов. Точнее,

hasNext и hasPrevious всегда возвращают false.
next и previous всегда вызывают NoSuchElementException.
remove и set всегда вызывают IllegalStateException.
add всегда вызывает UnsupportedOperationException.
nextIndex всегда возвращает 0.
previousIndex всегда возвращает -1.

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

Параметры типа:: T - тип элементов, если бы они были, в итераторе
Возвращает:: пустой итератор списка
С версии:: 1.7

emptyEnumeration

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

Возвращает перечисление, не содержащее элементов. Точнее,

hasMoreElements всегда возвращает false.
nextElement всегда вызывает NoSuchElementException.

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

Параметры типа:: T - класс объектов в перечислении
Возвращает:: пустое перечисление
С версии:: 1.7

emptySet

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

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

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

     Set<String> s = Collections.emptySet();

Примечание по реализации:

Реализации этого метода не обязательно создавать отдельный объект Set для каждого вызова. Использование этого метода, вероятно, будет сопоставимо по стоимости с использованием одноимённого поля. (В отличие от этого метода, поле не обеспечивает безопасность типов.)

Параметры типа:

T - класс объектов в множестве

Возвращает:

пустое множество

С версии:

1.5

См. также:

emptySortedSet

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

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

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

 
     SortedSet<String> s = Collections.emptySortedSet();

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

emptyNavigableSet

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

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

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

 
     NavigableSet<String> s = Collections.emptyNavigableSet();

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

emptyList

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

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

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

     List<String> s = Collections.emptyList();

Примечание по реализации:

Реализации этого метода не обязательно создавать отдельный объект List для каждого вызова. Использование этого метода, вероятно, будет сопоставимо по стоимости с использованием одноимённого поля. (В отличие от этого метода, поле не обеспечивает безопасность типов.)

Параметры типа:

T - тип элементов, если бы они были, в списке

Возвращает:

пустой неизменяемый список

С версии:

1.5

См. также:

emptyMap

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

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

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

     Map<String, Date> s = Collections.emptyMap();

Примечание по реализации:

Реализации этого метода не обязательно создавать отдельный объект Map для каждого вызова. Использование этого метода, вероятно, будет сопоставимо по стоимости с использованием одноимённого поля. (В отличие от этого метода, поле не обеспечивает безопасность типов.)

Параметры типа:

K - класс ключей карты

V - класс значений карты

Возвращает:

пустая карта

С версии:

1.5

См. также:

emptySortedMap

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

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

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

 
     SortedMap<String, Date> s = Collections.emptySortedMap();

Примечание по реализации:: Реализации этого метода не обязательно создавать отдельный объект SortedMap для каждого вызова.
Параметры типа:: K - класс ключей карты; V - класс значений карты
Возвращает:: пустая отсортированная карта
С версии:: 1.8

emptyNavigableMap

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

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

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

 
     NavigableMap<String, Date> s = Collections.emptyNavigableMap();

Примечание об реализации:: Реализации этого метода не обязаны создавать отдельный NavigableMap объект для каждого вызова.
Параметры типа:: K - класс ключей map; V - класс значений map
Возвращает:: пустой навигационный map
С тех пор:: 1.8

singleton

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

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

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

singletonList

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

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

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

singletonMap

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

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

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

nCopies

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

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

Параметры типа:

T - класс объекта для копирования и объектов в возвращаемом списке.

Параметры:

n - количество элементов в возвращаемом списке.

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

Возвращает:

неизменяемый список, состоящий из n копий указанного объекта.

Исключения:

IllegalArgumentException - если n < 0

См. также:

reverseOrder

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

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

          Arrays.sort(a, Collections.reverseOrder());

сортирует массив в обратном лексикографическом (алфавитном) порядке.

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

Примечание API:

Этот метод возвращает компаратор, подходящий для сортировки элементов в обратном порядке. Чтобы получить представление с обратным порядком сортировки упорядоченной коллекции, используйте метод SequencedCollection.reversed. Или, чтобы получить представление с обратным порядком сортировки упорядоченного map, используйте метод SequencedMap.reversed.

Параметры типа:

T - класс объектов, сравниваемых компаратором

Возвращает:

Компаратор, который накладывает обратный порядок сортировки по умолчанию на коллекцию объектов, которые реализуют интерфейс Comparable.

См. также:

reverseOrder

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

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

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

Примечание API:: Этот метод возвращает компаратор, подходящий для сортировки элементов в обратном порядке. Чтобы получить представление с обратным порядком сортировки упорядоченной коллекции, используйте метод SequencedCollection.reversed. Или, чтобы получить представление с обратным порядком сортировки упорядоченного map, используйте метод SequencedMap.reversed.
Параметры типа:: T - класс объектов, сравниваемых компаратором
Параметры:: cmp - компаратор, порядок которого должен быть изменен на обратный, возвращаемым компаратором, или null
Возвращает:: Компаратор, который накладывает обратный порядок сортировки, заданный указанным компаратором.
С тех пор:: 1.5

enumeration

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

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

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

Параметры типа:

T - класс объектов в коллекции

Параметры:

c - коллекция, для которой необходимо вернуть перечисление.

Возвращает:

перечисление над указанной коллекцией.

См. также:

list

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

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

Параметры типа:

T - класс объектов, возвращаемых перечислением

Параметры:

e - перечисление, предоставляющее элементы для возвращаемого списка array list

Возвращает:

список array list, содержащий элементы, возвращаемые указанным перечислением.

С тех пор:

1.4

См. также:

frequency

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

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

Параметры:: c - коллекция, в которой нужно определить частоту o; o - объект, частота которого должна быть определена
Возвращает:: количество элементов в c, равных o
Исключения:: NullPointerException - если c равно null
С тех пор:: 1.5

disjoint

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

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

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

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

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

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

addAll

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

Добавляет все указанные элементы в указанную коллекцию. Добавляемые элементы могут быть указаны индивидуально или как массив. Поведение этого вспомогательного метода аналогично поведению c.addAll(Collections.unmodifiableList(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

См. также:

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

newSequencedSetFromMap

public static <E> SequencedSet<E> newSequencedSetFromMap(SequencedMap<E,Boolean> map)

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

Примечание API:

Следующий пример кода создаёт SequencedSet из LinkedHashMap. Это отличается от LinkedHashSet тем, что removeEldestEntry карты переопределён, чтобы обеспечить политику удаления, что невозможно с LinkedHashSet.

    SequencedSet<String> set = Collections.newSequencedSetFromMap(
        new LinkedHashMap<String, Boolean>() {
            protected boolean removeEldestEntry(Map.Entry<String, Boolean> e) {
                return this.size() > 5;
            }
       });

Параметры типа:

E - класс ключей карты и объектов в возвращаемом множестве

Параметры:

map - базовое отображение

Возвращает:

множество, поддерживаемое картой

Исключения:

IllegalArgumentException - если map не пуста

С момента:

asLifoQueue

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

Возвращает представление Deque как очереди Last-in-first-out (Lifo). Метод add отображается на push, remove отображается на pop и так далее. Это представление может быть полезным, когда вам нужен метод, требующий Queue, но вам нужно упорядочение Lifo.

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

Примечание API:: Этот метод предоставляет представление, которое меняет смысл определённых операций, но не меняет порядок встречи. Для получения представленного в обратном порядке используйте метод Deque.reversed.
Параметры типа:: T - класс объектов в очереди
Параметры:: deque - очередь
Возвращает:: очередь
С момента:: 1.6

© 1993, 2025, 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://download.java.net/java/early_access/jdk24/docs/api/java.base/java/util/Collections.html