Наборы (Платформа Java SE 7)

java.lang. Объект
- java.util. Наборы

```
public class Collections
extends Object
```
Этот класс состоит исключительно из статических методов, которые работают на или наборы возврата. Это содержит полиморфные алгоритмы, которые работают на наборах, "обертках", которые возвращают новый набор, поддержанный указанным набором, и несколькими другими ненужными деталями.
Методы этого класса весь бросок NullPointerException, если наборы или объекты класса, предоставленные им, являются нулем.
Документация для полиморфных алгоритмов, содержавшихся в этом классе обычно, включает краткое описание реализации. Такие описания должны быть расценены, как реализация отмечает, а не отделяется спецификации. Конструкторы должны не стесняться заменять другими алгоритмами, пока сама спецификация придерживается к. (Например, алгоритм, используемый sort, не должен быть сортировкой с объединением, но это действительно должно быть устойчиво.)
"Разрушительные" алгоритмы, содержавшиеся в этом классе, то есть, алгоритмы, которые изменяют набор, на котором они работают, определяются, чтобы бросить UnsupportedOperationException, если набор не поддерживает соответствующую мутацию, примитивную (s), такой как метод set. Эти алгоритмы, но не обязаны, может выдать это исключение, если вызов не имел бы никакого эффекта на набор. Например, вызов метода sort в неподдающемся изменению списке, который уже сортируется, может или, возможно, не бросает UnsupportedOperationException.
Этот класс является элементом Платформы Наборов Java.

С тех пор:

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)` Возвращает представление a `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 <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()` Возвращает iterator, у которого нет никаких элементов.
`static <T> List<T>`	`emptyList()` Возвращает пустой (неизменный) список.
`static <T> ListIterator<T>`	`emptyListIterator()` Возвращает список iterator, у которого нет никаких элементов.
`static <K,V> Map<K,V>`	`emptyMap()` Возвращает пустую (неизменную) карту.
`static <T> Set<T>`	`emptySet()` Возвращает (неизменное) пустое множество.
`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 <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 <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 унаследованный от класса. Объект
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()
- Деталь метода
  - вид
```
public static <T extends Comparable<? super T>> void sort(List<T> list)
```
    Сортирует указанный список в порядок по возрастанию, согласно естественному упорядочиванию его элементов. Все элементы в списке должны реализовать Comparable интерфейс. Кроме того все элементы в списке должны быть взаимно сопоставимыми (то есть, e1.compareTo(e2) не должен бросить a ClassCastException для любых элементов e1 и e2 в списке).
    Этот вид, как гарантируют, будет устойчив: равные элементы не будут переупорядочены в результате вида.
    Указанный список должен быть поддающимся изменению, но не должен быть изменяемого размера.
    Примечание реализации: Эта реализация является устойчивой, адаптивной, итеративной сортировкой с объединением, которая требует гораздо меньше чем n lg (n) сравнения, когда входной массив частично сортируется, предлагая производительность традиционной сортировки с объединением, когда входному массиву в произвольном порядке упорядочивают. Если входной массив почти сортируется, реализация требует приблизительно n сравнений. Временные требования хранения изменяются от маленькой константы для почти сортированных входных массивов к n/2 ссылкам на объект для в произвольном порядке упорядоченных входных массивов.
    Реализация пользуется равным преимуществом порядка по возрастанию и порядка по убыванию в его входном массиве, и может использовать в своих интересах порядок по возрастанию и порядка по убыванию в различных частях того же самого входного массива. Это является подходящим к слиянию двух или больше сортированных массивов: просто свяжите массивы и сортируйте получающийся массив.
    Реализация была адаптирована от вида списка Тима Петерса к Python (TimSort). Это использует techiques от "Оптимистической Сортировки Питера Макилроя и информации Теоретическая Сложность", в Продолжениях Четвертого Ежегодного Симпозиума ACM-СИАМА по Дискретным Алгоритмам, стр 467-474, январь 1993.
    Эта реализация выводит указанный список в массив, сортирует массив, и выполняет итерации по списку, сбрасывающему каждый элемент от соответствующей позиции в массиве. Это избегает журнала ⁿ² (n) производительность, которая следовала бы из попытки сортировать связанный список на месте.
    
    Параметры:
    list - список, который будет сортирован.
    
    Броски:
    
    ClassCastException - если список содержит элементы, которые не взаимно сопоставимы (например, строки и целые числа).
    
    UnsupportedOperationException - если список-iterator указанного списка не поддерживает set работа.
    
    IllegalArgumentException - (дополнительный), если реализация обнаруживает, что естественное упорядочивание элементов списка, как находят, нарушает Comparable контракт
  - вид
```
public static <T> void sort(List<T> list,
            Comparator<? super T> c)
```
    Сортирует указанный список согласно порядку, вызванному указанным компаратором. Все элементы в списке должны быть взаимно сопоставимым использованием указанного компаратора (то есть, c.compare(e1, e2) не должен бросить a ClassCastException для любых элементов e1 и e2 в списке).
    Этот вид, как гарантируют, будет устойчив: равные элементы не будут переупорядочены в результате вида.
    Указанный список должен быть поддающимся изменению, но не должен быть изменяемого размера.
    Примечание реализации: Эта реализация является устойчивой, адаптивной, итеративной сортировкой с объединением, которая требует гораздо меньше чем n lg (n) сравнения, когда входной массив частично сортируется, предлагая производительность традиционной сортировки с объединением, когда входному массиву в произвольном порядке упорядочивают. Если входной массив почти сортируется, реализация требует приблизительно n сравнений. Временные требования хранения изменяются от маленькой константы для почти сортированных входных массивов к n/2 ссылкам на объект для в произвольном порядке упорядоченных входных массивов.
    Реализация пользуется равным преимуществом порядка по возрастанию и порядка по убыванию в его входном массиве, и может использовать в своих интересах порядок по возрастанию и порядка по убыванию в различных частях того же самого входного массива. Это является подходящим к слиянию двух или больше сортированных массивов: просто свяжите массивы и сортируйте получающийся массив.
    Реализация была адаптирована от вида списка Тима Петерса к Python (TimSort). Это использует techiques от "Оптимистической Сортировки Питера Макилроя и информации Теоретическая Сложность", в Продолжениях Четвертого Ежегодного Симпозиума ACM-СИАМА по Дискретным Алгоритмам, стр 467-474, январь 1993.
    Эта реализация выводит указанный список в массив, сортирует массив, и выполняет итерации по списку, сбрасывающему каждый элемент от соответствующей позиции в массиве. Это избегает журнала ⁿ² (n) производительность, которая следовала бы из попытки сортировать связанный список на месте.
    
    Параметры:
    list - список, который будет сортирован.
    c - компаратор, чтобы определить порядок списка. A null значение указывает, что естественное упорядочивание элементов должно использоваться.
    
    Броски:
    
    ClassCastException - если список содержит элементы, которые не являются взаимно сопоставимым использованием указанного компаратора.
    
    UnsupportedOperationException - если список-iterator указанного списка не поддерживает set работа.
    
    IllegalArgumentException - (дополнительный), если компаратор, как находят, нарушает Comparator контракт
  - binarySearch
```
public static <T> int binarySearch(List<? extends Comparable<? super T>> list,
                   T key)
```
    Ищет указанный список указанный объект, используя алгоритм двоичного поиска. Список должен быть сортирован в порядок по возрастанию согласно естественному упорядочиванию его элементов (как sort(List) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если список содержит многократные элементы, равные указанному объекту, нет никакой гарантии, которой будет найден.
    Этот метод выполняет в журнале (n) время для списка "произвольного доступа" (который обеспечивает "около постоянного времени" позиционный доступ). Если указанный список не реализует RandomAccess взаимодействуйте через интерфейс и является большим, этот метод сделает iterator-на-основе двоичный поиск, который выполняет O (n) обходы ссылки, и O (зарегистрируйте n), сравнения элемента.
    
    Параметры:
    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) метод), до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если список содержит многократные элементы, равные указанному объекту, нет никакой гарантии, которой будет найден.
    Этот метод выполняет в журнале (n) время для списка "произвольного доступа" (который обеспечивает "около постоянного времени" позиционный доступ). Если указанный список не реализует RandomAccess взаимодействуйте через интерфейс и является большим, этот метод сделает iterator-на-основе двоичный поиск, который выполняет O (n) обходы ссылки, и O (зарегистрируйте n), сравнения элемента.
    
    Параметры:
    list - список, который будет искаться.
    key - ключ, который будет разыскиваться.
    c - компаратор, которым упорядочивается список. Значение null указывает, что естественное упорядочивание элементов должно использоваться.
    
    Возвраты:
    индекс ключа поиска, если это содержится в списке; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в список: индекс первого элемента, больше чем ключ, или list.size(), если все элементы в списке являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
    
    Броски:
    
    ClassCastException - если список содержит элементы, которые не являются взаимно сопоставимым использованием указанного компаратора, или ключ поиска не взаимно сопоставим с элементами списка, используя этот компаратор.
  - реверс
```
public static void reverse(List<?> list)
```
    Инвертирует порядок элементов в указанном списке.
    В линейное время работает этот метод.
    
    Параметры:
    list - список, элементы которого должны быть инвертированы.
    
    Броски:
    
    UnsupportedOperationException - если указанный список или его список-iterator не поддерживают работу set.
  - перестановка
```
public static void shuffle(List<?> list)
```
    В произвольном порядке переставляет указанный список, используя источник по умолчанию случайности. Все перестановки происходят с приблизительно равной вероятностью.
    Преграда "приблизительно" используется в предшествующем описании, потому что источник по умолчанию случайности является только приблизительно несмещенным источником независимо выбранных битов. Если бы это был совершенный источник в произвольном порядке выбранных битов, то алгоритм выбрал бы перестановки с совершенной однородностью.
    Эта реализация пересекает список назад, от последнего элемента до второго, неоднократно подкачивая в произвольном порядке выбранный элемент в "текущую позицию". Элементы в произвольном порядке выбираются из части списка, который работает от первого элемента до текущей позиции, включительно.
    В линейное время работает этот метод. Если указанный список не реализует RandomAccess взаимодействуйте через интерфейс и является большим, эта реализация выводит указанный список в массив прежде, чем переставить это, и выводит переставленный массив назад в список. Это избегает квадратного поведения, которое следовало бы из перестановки "с последовательным доступом" списка на месте.
    
    Параметры:
    list - список, который будет переставлен.
    
    Броски:
    
    UnsupportedOperationException - если указанный список или его список-iterator не поддерживают работу set.
  - перестановка
```
public static void shuffle(List<?> list,
           Random rnd)
```
    В произвольном порядке переставьте указанный список, используя указанный источник случайности. Все перестановки происходят с равной вероятностью, предполагающей, что источник случайности справедлив.
    Эта реализация пересекает список назад, от последнего элемента до второго, неоднократно подкачивая в произвольном порядке выбранный элемент в "текущую позицию". Элементы в произвольном порядке выбираются из части списка, который работает от первого элемента до текущей позиции, включительно.
    В линейное время работает этот метод. Если указанный список не реализует RandomAccess взаимодействуйте через интерфейс и является большим, эта реализация выводит указанный список в массив прежде, чем переставить это, и выводит переставленный массив назад в список. Это избегает квадратного поведения, которое следовало бы из перестановки "с последовательным доступом" списка на месте.
    
    Параметры:
    list - список, который будет переставлен.
    rnd - источник случайности, чтобы использовать, чтобы переставить список.
    
    Броски:
    
    UnsupportedOperationException - если указанный список или его список-iterator не поддерживают работу set.
  - подкачка
```
public static void swap(List<?> list,
        int i,
        int j)
```
    Подкачивает элементы в указанных позициях в указанном списке. (Если указанные позиции равны, вызывая этот метод листы неизменный список.)
    
    Параметры:
    list - Список, в котором можно подкачать элементы.
    i - индекс одного элемента, который будет подкачан.
    j - индекс другого элемента, который будет подкачан.
    
    Броски:
    
    IndexOutOfBoundsException - если или i или j испытывают недостаток диапазона (я <0 || i> = list.size () || j <0 || j> = list.size ()).
    С тех пор:
    
    1.4
  - заливка
```
public static <T> void fill(List<? super T> list,
            T obj)
```
    Замены все элементы указанного списка с указанным элементом.
    В линейное время работает этот метод.
    
    Параметры:
    list - список, чтобы быть заполненным указанным элементом.
    obj - Элемент, которым можно заполнить указанный список.
    
    Броски:
    
    UnsupportedOperationException - если указанный список или его список-iterator не поддерживают работу set.
  - копия
```
public static <T> void copy(List<? super T> dest,
            List<? extends T> src)
```
    Копии все элементы от одного списка в другого. После работы индекс каждого скопированного элемента в целевом списке будет идентичен его индексу в исходном списке. Целевой список должен быть, по крайней мере, пока исходный список. Если это более длинно, остающиеся элементы в целевом списке незатронуты.
    В линейное время работает этот метод.
    
    Параметры:
    dest - Целевой список.
    src - Исходный список.
    
    Броски:
    
    IndexOutOfBoundsException - если целевой список является слишком маленьким, чтобы содержать весь исходный Список.
    
    UnsupportedOperationException - если целевой список-iterator списка не поддерживает работу set.
  - минута
```
public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
```
    Возвращает минимальный элемент данного набора, согласно естественному упорядочиванию его элементов. Все элементы в наборе должны реализовать интерфейс Comparable. Кроме того все элементы в наборе должны быть взаимно сопоставимыми (то есть, e1.compareTo(e2) не должен бросить ClassCastException для любых элементов e1 и e2 в наборе).
    Этот метод выполняет итерации по всему набору, следовательно требуется время, пропорциональное размеру набора.
    
    Параметры:
    coll - набор, минимальный элемент которого должен быть определен.
    
    Возвраты:
    минимальный элемент данного набора, согласно естественному упорядочиванию его элементов.
    
    Броски:
    
    ClassCastException - если набор содержит элементы, которые не взаимно сопоставимы (например, строки и целые числа).
    
    NoSuchElementException - если набор пуст.
    См. Также:
    Comparable
  - минута
```
public static <T> T min(Collection<? extends T> coll,
        Comparator<? super T> comp)
```
    Возвращает минимальный элемент данного набора, согласно порядку, вызванному указанным компаратором. Все элементы в наборе должны быть взаимно сопоставимыми указанным компаратором (то есть, comp.compare(e1, e2) не должен бросить ClassCastException для любых элементов e1 и e2 в наборе).
    Этот метод выполняет итерации по всему набору, следовательно требуется время, пропорциональное размеру набора.
    
    Параметры:
    coll - набор, минимальный элемент которого должен быть определен.
    comp - компаратор, с которым можно определить минимальный элемент. Значение null указывает, что естественное упорядочивание элементов должно использоваться.
    
    Возвраты:
    минимальный элемент данного набора, согласно указанному компаратору.
    
    Броски:
    
    ClassCastException - если набор содержит элементы, которые не являются взаимно сопоставимым использованием указанного компаратора.
    
    NoSuchElementException - если набор пуст.
    См. Также:
    Comparable
  - максимальный
```
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
```
    Возвращает максимальный элемент данного набора, согласно естественному упорядочиванию его элементов. Все элементы в наборе должны реализовать интерфейс Comparable. Кроме того все элементы в наборе должны быть взаимно сопоставимыми (то есть, e1.compareTo(e2) не должен бросить ClassCastException для любых элементов e1 и e2 в наборе).
    Этот метод выполняет итерации по всему набору, следовательно требуется время, пропорциональное размеру набора.
    
    Параметры:
    coll - набор, максимальный элемент которого должен быть определен.
    
    Возвраты:
    максимальный элемент данного набора, согласно естественному упорядочиванию его элементов.
    
    Броски:
    
    ClassCastException - если набор содержит элементы, которые не взаимно сопоставимы (например, строки и целые числа).
    
    NoSuchElementException - если набор пуст.
    См. Также:
    Comparable
  - максимальный
```
public static <T> T max(Collection<? extends T> coll,
        Comparator<? super T> comp)
```
    Возвращает максимальный элемент данного набора, согласно порядку, вызванному указанным компаратором. Все элементы в наборе должны быть взаимно сопоставимыми указанным компаратором (то есть, comp.compare(e1, e2) не должен бросить ClassCastException для любых элементов e1 и e2 в наборе).
    Этот метод выполняет итерации по всему набору, следовательно требуется время, пропорциональное размеру набора.
    
    Параметры:
    coll - набор, максимальный элемент которого должен быть определен.
    comp - компаратор, с которым можно определить максимальный элемент. Значение null указывает, что естественное упорядочивание элементов должно использоваться.
    
    Возвраты:
    максимальный элемент данного набора, согласно указанному компаратору.
    
    Броски:
    
    ClassCastException - если набор содержит элементы, которые не являются взаимно сопоставимым использованием указанного компаратора.
    
    NoSuchElementException - если набор пуст.
    См. Также:
    Comparable
  - вращаться
```
public static void rotate(List<?> list,
          int distance)
```
    Поворачивает элементы в указанном списке указанным расстоянием. После вызова этого метода элемента по индексу i будет элементом ранее по индексу модник (i - distance) list.size(), для всех значений i между 0 и list.size()-1, включительно. (Этот метод не имеет никакого эффекта на размер списка.)
    Например, предположите list comprises [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 из Жемчуга Программирования Бентли Джона (Аддисон-Уэсли, 1986).
    Параметры:
    list - список, который будет повернут.
    distance - расстояние, чтобы повернуть список. Нет никаких ограничений на это значение; это может быть нуль, отрицательный, или больше чем list.size().
    
    Броски:
    
    UnsupportedOperationException - если указанный список или его список-iterator не поддерживают работу 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)). (Этот метод не имеет никакого эффекта на размер списка.)
    
    Параметры:
    list - список, в котором должна произойти замена.
    oldVal - старое значение, которое будет заменено.
    newVal - новое значение, которым должен быть заменен oldVal.
    
    Возвраты:
    true, если list содержавший или больше элементов e так, что (oldVal==null ? e==null : oldVal.equals(e)).
    
    Броски:
    
    UnsupportedOperationException - если указанный список или его список-iterator не поддерживают работу 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)
```
    Возвращает неподдающееся изменению представление указанного набора. Этот метод позволяет модулям предоставлять пользователям доступ "только для чтения" к внутренним наборам. Операции запроса на возвращенном наборе, "прочитанном" к указанному набору, и попыткам изменить возвращенный набор, или прямой или через его iterator, приводят к UnsupportedOperationException.
    Возвращенный набор не передает хэш-код и равняется операциям через отступающему набору, но полагается на методы equals И hashCode Object. Это необходимо, чтобы сохранить контракты этих операций в случае, что отступающий набор является набором или списком.
    Возвращенный набор будет сериализуем, если указанный набор будет сериализуем.
    
    Параметры:
    c - набор, для которого должно быть возвращено неподдающееся изменению представление.
    
    Возвраты:
    неподдающееся изменению представление указанного набора.
  - unmodifiableSet
```
public static <T> Set<T> unmodifiableSet(Set<? extends T> s)
```
    Возвращает неподдающееся изменению представление указанного набора. Этот метод позволяет модулям предоставлять пользователям доступ "только для чтения" к внутренним наборам. Операции запроса на возвращенном наборе, "прочитанном" к указанному набору, и попыткам изменить возвращенный набор, или прямой или через его iterator, приводят к UnsupportedOperationException.
    Возвращенный набор будет сериализуем, если указанный набор будет сериализуем.
    
    Параметры:
    s - набор, для которого должно быть возвращено неподдающееся изменению представление.
    
    Возвраты:
    неподдающееся изменению представление указанного набора.
  - unmodifiableSortedSet
```
public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)
```
    Возвращает неподдающееся изменению представление указанного сортированного набора. Этот метод позволяет модулям предоставлять пользователям доступ "только для чтения" к внутренним сортированным наборам. Операции запроса на возвращенном отсортированном наборе "чтение" к указанному сортированному набору. Попытки изменить возвращенный сортированный набор, приводит ли прямой, через его iterator, или через его subSet, headSet, или представления tailSet, к UnsupportedOperationException.
    Возвращенный сортированный набор будет сериализуем, если указанный сортированный набор будет сериализуем.
    
    Параметры:
    s - сортированный набор, для которого должно быть возвращено неподдающееся изменению представление.
    
    Возвраты:
    неподдающееся изменению представление указанного сортированного набора.
  - unmodifiableList
```
public static <T> List<T> unmodifiableList(List<? extends T> list)
```
    Возвращает неподдающееся изменению представление указанного списка. Этот метод позволяет модулям предоставлять пользователям доступ "только для чтения" к внутренним спискам. Операции запроса в возвращенном списке, "прочитанном" к указанному списку, и попыткам изменить возвращенный список, или прямой или через его iterator, приводят к UnsupportedOperationException.
    Возвращенный список будет сериализуем, если указанный список будет сериализуем. Точно так же возвращенный список реализует RandomAccess если указанный список делает.
    
    Параметры:
    list - список, для которого должно быть возвращено неподдающееся изменению представление.
    
    Возвраты:
    неподдающееся изменению представление указанного списка.
  - unmodifiableMap
```
public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m)
```
    Возвращает неподдающееся изменению представление указанной карты. Этот метод позволяет модулям предоставлять пользователям доступ "только для чтения" к внутренним картам. Операции запроса на возвращенной карте, "прочитанной" к указанной карте, и попыткам изменить возвращенную карту, или прямой или через ее представления набора, приводят к UnsupportedOperationException.
    Возвращенная карта будет сериализуема, если указанная карта будет сериализуема.
    
    Параметры:
    m - карта, для которой должно быть возвращено неподдающееся изменению представление.
    
    Возвраты:
    неподдающееся изменению представление указанной карты.
  - unmodifiableSortedMap
```
public static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m)
```
    Возвращает неподдающееся изменению представление указанной сортированной карты. Этот метод позволяет модулям предоставлять пользователям доступ "только для чтения" к внутренним сортированным картам. Операции запроса на возвращенной отсортированной карте "чтение" к указанной сортированной карте. Попытки изменить возвращенную сортированную карту, приводит ли прямой, через ее представления набора, или через ее subMap, headMap, или представления tailMap, к UnsupportedOperationException.
    Возвращенная сортированная карта будет сериализуема, если указанная сортированная карта будет сериализуема.
    
    Параметры:
    m - сортированная карта, для которой должно быть возвращено неподдающееся изменению представление.
    
    Возвраты:
    неподдающееся изменению представление указанной сортированной карты.
  - synchronizedCollection
```
public static <T> Collection<T> synchronizedCollection(Collection<T> c)
```
    Возвращает синхронизируемый (ориентированный на многопотоковое исполнение) набор, поддержанный указанным набором. Чтобы гарантировать последовательный доступ, является критическим, что весь доступ к отступающему набору выполняется через возвращенный набор.
    Обязательно, чтобы пользователь вручную синхронизировался на возвращенном наборе, выполняя итерации по этому:
```
  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 через к отступающему набору, но полагается на Object, равняется и методы хэш-кода. Это необходимо, чтобы сохранить контракты этих операций в случае, что отступающий набор является набором или списком.
    Возвращенный набор будет сериализуем, если указанный набор будет сериализуем.
    Параметры:
    c - набор, который будет "обернут" в синхронизируемый набор.
    
    Возвраты:
    синхронизируемое представление указанного набора.
  - 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());
  }
 
```
    Отказ последовать этому совету может привести к недетерминированному поведению.
    Возвращенный набор будет сериализуем, если указанный набор будет сериализуем.
    Параметры:
    s - набор, который будет "обернут" в синхронизируемый набор.
    
    Возвраты:
    синхронизируемое представление указанного набора.
  - synchronizedSortedSet
```
public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)
```
    Возвращает синхронизируемый (ориентированный на многопотоковое исполнение) сортированный набор, поддержанный указанным сортированным набором. Чтобы гарантировать последовательный доступ, является критическим, что весь доступ к поддержке сортированный набор выполняется через возвращенный сортированный набор (или его представления).
    Обязательно, чтобы пользователь вручную синхронизировался на возвращенном сортированном наборе, выполняя итерации по этому или любом его subSet, headSet, или представлениях tailSet.
```
  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());
  }
 
```
    Отказ последовать этому совету может привести к недетерминированному поведению.
    Возвращенный сортированный набор будет сериализуем, если указанный сортированный набор будет сериализуем.
    Параметры:
    s - сортированный набор, который будет "обернут" в синхронизируемый сортированный набор.
    
    Возвраты:
    синхронизируемое представление указанного сортированного набора.
  - synchronizedList
```
public static <T> List<T> synchronizedList(List<T> list)
```
    Возвращает синхронизируемый (ориентированный на многопотоковое исполнение) список, поддержанный указанным списком. Чтобы гарантировать последовательный доступ, является критическим, что весь доступ к отступающему списку выполняется через возвращенный список.
    Обязательно, чтобы пользователь вручную синхронизировался в возвращенном списке, выполняя итерации по этому:
```
  List list = Collections.synchronizedList(new ArrayList());
      ...
  synchronized (list) {
      Iterator i = list.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }
 
```
    Отказ последовать этому совету может привести к недетерминированному поведению.
    Возвращенный список будет сериализуем, если указанный список будет сериализуем.
    Параметры:
    list - список, который будет "обернут" в синхронизируемый список.
    
    Возвраты:
    синхронизируемое представление указанного списка.
  - synchronizedMap
```
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
```
    Возвращает синхронизируемую (ориентированную на многопотоковое исполнение) карту, поддержанную указанной картой. Чтобы гарантировать последовательный доступ, является критическим, что весь доступ к отступающей карте выполняется через возвращенную карту.
    Обязательно, чтобы пользователь вручную синхронизировался на возвращенной карте, выполняя итерации по любому из ее представлений набора:
```
  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());
  }
 
```
    Отказ последовать этому совету может привести к недетерминированному поведению.
    Возвращенная карта будет сериализуема, если указанная карта будет сериализуема.
    Параметры:
    m - карта, которая будет "обернута" в синхронизируемую карту.
    
    Возвраты:
    синхронизируемое представление указанной карты.
  - synchronizedSortedMap
```
public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
```
    Возвращает синхронизируемую (ориентированную на многопотоковое исполнение) сортированную карту, поддержанную указанной сортированной картой. Чтобы гарантировать последовательный доступ, является критическим, что весь доступ к поддержке сортированная карта выполняется через возвращенную сортированную карту (или ее представления).
    Обязательно, чтобы пользователь вручную синхронизировался на возвращенной сортированной карте, выполняя итерации по любому из ее представлений набора, или представлений наборов любого ее subMap, headMap или представлений tailMap.
```
  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 = s.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }
 
```
    Отказ последовать этому совету может привести к недетерминированному поведению.
    Возвращенная сортированная карта будет сериализуема, если указанная сортированная карта будет сериализуема.
    Параметры:
    m - сортированная карта, которая будет "обернута" в синхронизируемую сортированную карту.
    
    Возвраты:
    синхронизируемое представление указанной сортированной карты.
  - checkedCollection
```
public static <E> Collection<E> checkedCollection(Collection<E> c,
                                  Class<E> type)
```
    Возвращает динамически безопасное с точки зрения типов представление указанного набора. Любая попытка вставить элемент неправильного типа приведет к непосредственному ClassCastException. Принятие набора не содержит неправильно введенных элементов до тех пор, пока динамически безопасное с точки зрения типов представление сгенерировано, и что весь последующий доступ к набору имеет место посредством представления, гарантируется, что набор не может содержать неправильно введенный элемент.
    Механизм обобщений на языке обеспечивает время компиляции (статическая) проверка типа, но возможно победить этот механизм с бросками непроверенными. Обычно это не проблема как предупреждения проблем компилятора на всех таких операциях непроверенных. Есть, однако, времена, когда одна только статическая проверка типа не достаточна. Например, предположите, что набор передают к сторонней библиотеке, и обязательно, чтобы код библиотеки не повредил набор, вставляя элемент неправильного типа.
    Другое использование динамически безопасных с точки зрения типов представлений отлаживает. Предположите, что программа перестала работать с a ClassCastException, указание, что неправильно введенный элемент был помещен в параметризованный набор. К сожалению, исключение может произойти в любое время после того, как ошибочный элемент вставляется, таким образом, это обычно предоставляет немного или нисколько информации относительно реального источника проблемы. Если проблема восстанавливаема, можно быстро определить ее источник, временно изменяя программу, чтобы обернуть набор с динамически безопасным с точки зрения типов представлением. Например, это объявление:
```
 Collection<String> c = new HashSet<String>();
 
```
    может быть заменен временно этим:
```
 Collection<String> c = Collections.checkedCollection(
         new HashSet<String>(), String.class);
 
```
    Выполнение программы снова заставит это перестать работать в точке, где неправильно введенный элемент вставляется в набор, ясно идентифицируя источник проблемы. Как только проблема решается, измененное объявление может вернуться назад к оригиналу.
    Возвращенный набор не передает хэш-код и равняется операциям через отступающему набору, но полагается Object's equals и hashCode методы. Это необходимо, чтобы сохранить контракты этих операций в случае, что отступающий набор является набором или списком.
    Возвращенный набор будет сериализуем, если указанный набор будет сериализуем.
    С тех пор null как полагают, значение любого ссылочного типа, возвращенный набор разрешает вставку нулевых элементов всякий раз, когда отступающий набор делает.
    Параметры:
    c - набор, для которого должно быть возвращено динамически безопасное с точки зрения типов представление
    type - тип элемента это c разрешается содержать
    
    Возвраты:
    динамически безопасное с точки зрения типов представление указанного набора
    С тех пор:
    
    1.5
  - checkedSet
```
public static <E> Set<E> checkedSet(Set<E> s,
                    Class<E> type)
```
    Возвращает динамически безопасное с точки зрения типов представление указанного набора. Любая попытка вставить элемент неправильного типа приведет к непосредственному ClassCastException. Принятие набора не содержит неправильно введенных элементов до тех пор, пока динамически безопасное с точки зрения типов представление сгенерировано, и что весь последующий доступ к набору имеет место посредством представления, гарантируется, что набор не может содержать неправильно введенный элемент.
    Обсуждение использования динамически безопасных с точки зрения типов представлений может быть найдено в документации для checkedCollection метод.
    Возвращенный набор будет сериализуем, если указанный набор будет сериализуем.
    С тех пор null как полагают, значение любого ссылочного типа, возвращенный набор разрешает вставку нулевых элементов всякий раз, когда набор поддержки делает.
    
    Параметры:
    s - набор, для которого должно быть возвращено динамически безопасное с точки зрения типов представление
    type - тип элемента это s разрешается содержать
    
    Возвраты:
    динамически безопасное с точки зрения типов представление указанного набора
    С тех пор:
    
    1.5
  - checkedSortedSet
```
public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s,
                                Class<E> type)
```
    Возвращает динамически безопасное с точки зрения типов представление указанного сортированного набора. Любая попытка вставить элемент неправильного типа приведет к непосредственному ClassCastException. Принятие сортированного набора не содержит неправильно введенных элементов до тех пор, пока динамически безопасное с точки зрения типов представление сгенерировано, и что весь последующий доступ к сортированному набору имеет место посредством представления, гарантируется, что сортированный набор не может содержать неправильно введенный элемент.
    Обсуждение использования динамически безопасных с точки зрения типов представлений может быть найдено в документации для checkedCollection метод.
    Возвращенный сортированный набор будет сериализуем, если указанный сортированный набор будет сериализуем.
    С тех пор null как полагают, значение любого ссылочного типа, возвращенный сортированный набор разрешает вставку нулевых элементов всякий раз, когда поддержка сортированный набор делает.
    
    Параметры:
    s - сортированный набор, для которого должно быть возвращено динамически безопасное с точки зрения типов представление
    type - тип элемента это s разрешается содержать
    
    Возвраты:
    динамически безопасное с точки зрения типов представление указанного сортированного набора
    С тех пор:
    
    1.5
  - checkedList
```
public static <E> List<E> checkedList(List<E> list,
                      Class<E> type)
```
    Возвращает динамически безопасное с точки зрения типов представление указанного списка. Любая попытка вставить элемент неправильного типа приведет к непосредственному ClassCastException. Принятие списка не содержит неправильно введенных элементов до тех пор, пока динамически безопасное с точки зрения типов представление сгенерировано, и что весь последующий доступ к списку имеет место посредством представления, гарантируется, что список не может содержать неправильно введенный элемент.
    Обсуждение использования динамически безопасных с точки зрения типов представлений может быть найдено в документации для checkedCollection метод.
    Возвращенный список будет сериализуем, если указанный список будет сериализуем.
    С тех пор null как полагают, значение любого ссылочного типа, возвращенный список разрешает вставку нулевых элементов всякий раз, когда отступающий список делает.
    
    Параметры:
    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, предпринимается ли модификация непосредственно через карту непосредственно, или через a Map.Entry экземпляр получается из карты entry set представление.
    Принятие карты не содержит неправильно введенных ключей или значений до тех пор, пока динамически безопасное с точки зрения типов представление сгенерировано, и что весь последующий доступ к карте имеет место посредством представления (или одно из его представлений набора), гарантируется, что карта не может содержать неправильно введенный ключ или значение.
    Обсуждение использования динамически безопасных с точки зрения типов представлений может быть найдено в документации для checkedCollection метод.
    Возвращенная карта будет сериализуема, если указанная карта будет сериализуема.
    С тех пор null как полагают, значение любого ссылочного типа, возвращенная карта разрешает вставку нулевых ключей или значений всякий раз, когда отступающая карта делает.
    
    Параметры:
    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, предпринимается ли модификация непосредственно через карту непосредственно, или через a Map.Entry экземпляр получается из карты entry set представление.
    Принятие карты не содержит неправильно введенных ключей или значений до тех пор, пока динамически безопасное с точки зрения типов представление сгенерировано, и что весь последующий доступ к карте имеет место посредством представления (или одно из его представлений набора), гарантируется, что карта не может содержать неправильно введенный ключ или значение.
    Обсуждение использования динамически безопасных с точки зрения типов представлений может быть найдено в документации для checkedCollection метод.
    Возвращенная карта будет сериализуема, если указанная карта будет сериализуема.
    С тех пор null как полагают, значение любого ссылочного типа, возвращенная карта разрешает вставку нулевых ключей или значений всякий раз, когда отступающая карта делает.
    
    Параметры:
    m - карта, для которой должно быть возвращено динамически безопасное с точки зрения типов представление
    keyType - тип ключа это m разрешается содержать
    valueType - тип имеющий значение это m разрешается содержать
    
    Возвраты:
    динамически безопасное с точки зрения типов представление указанной карты
    С тех пор:
    
    1.5
  - emptyIterator
```
public static <T> Iterator<T> emptyIterator()
```
    Возвращает iterator, у которого нет никаких элементов. Более точно,
    - hasNext всегда возвраты false.
    - next всегда броски NoSuchElementException.
    - remove всегда броски IllegalStateException.
    Реализации этого метода разрешаются, но не требуются, чтобы возвратить тот же самый объект из многократных вызовов.
    Возвраты:
    пустой iterator
    С тех пор:
    
    1.7
  - emptyListIterator
```
public static <T> ListIterator<T> emptyListIterator()
```
    Возвращает список iterator, у которого нет никаких элементов. Более точно,
    - hasNext и hasPrevious всегда возвращайтесь false.
    - next и previous всегда бросок NoSuchElementException.
    - remove и set всегда бросок IllegalStateException.
    - add всегда броски UnsupportedOperationException.
    - nextIndex всегда возвраты 0 .
    - previousIndex всегда возвраты -1.
    Реализации этого метода разрешаются, но не требуются, чтобы возвратить тот же самый объект из многократных вызовов.
    Возвраты:
    пустой список iterator
    С тех пор:
    
    1.7
  - emptyEnumeration
```
public static <T> Enumeration<T> emptyEnumeration()
```
    Возвращает перечисление, у которого нет никаких элементов. Более точно,
    - hasMoreElements всегда возвраты false.
    - nextElement всегда броски NoSuchElementException.
    Реализации этого метода разрешаются, но не требуются, чтобы возвратить тот же самый объект из многократных вызовов.
    Возвраты:
    пустое перечисление
    С тех пор:
    
    1.7
  - пустое множество
```
public static final <T> Set<T> emptySet()
```
    Возвращает (неизменное) пустое множество. Этот набор сериализуем. В отличие от подобно-именованного поля, параметризован этот метод.
    Этот пример иллюстрирует безопасный с точки зрения типов способ получить пустое множество:
```
     Set<String> s = Collections.emptySet();
 
```
    Примечание реализации: Реализации этого метода не должны создать отдельный объект Set для каждого вызова. Используя этот метод, вероятно, будет иметь сопоставимую стоимость для использования подобно-именованного поля. (В отличие от этого метода, поле не обеспечивает безопасность типов.)
    С тех пор:
    
    1.5
    
    См. Также:
    EMPTY_SET
  - emptyList
```
public static final <T> List<T> emptyList()
```
    Возвращает пустой (неизменный) список. Этот список сериализуем.
    Этот пример иллюстрирует безопасный с точки зрения типов способ получить пустой список:
```
     List<String> s = Collections.emptyList();
 
```
    Примечание реализации: Реализации этого метода не должны создать отдельный объект List для каждого вызова. Используя этот метод, вероятно, будет иметь сопоставимую стоимость для использования подобно-именованного поля. (В отличие от этого метода, поле не обеспечивает безопасность типов.)
    С тех пор:
    
    1.5
    
    См. Также:
    EMPTY_LIST
  - emptyMap
```
public static final <K,V> Map<K,V> emptyMap()
```
    Возвращает пустую (неизменную) карту. Эта карта сериализуема.
    Этот пример иллюстрирует безопасный с точки зрения типов способ получить пустое множество:
```
     Map<String, Date> s = Collections.emptyMap();
 
```
    Примечание реализации: Реализации этого метода не должны создать отдельный объект Map для каждого вызова. Используя этот метод, вероятно, будет иметь сопоставимую стоимость для использования подобно-именованного поля. (В отличие от этого метода, поле не обеспечивает безопасность типов.)
    С тех пор:
    
    1.5
    
    См. Также:
    EMPTY_MAP
  - одиночный элемент
```
public static <T> Set<T> singleton(T o)
```
    Возвращает неизменный набор, содержащий только указанный объект. Возвращенный набор сериализуем.
    
    Параметры:
    o - единственный объект, который будет сохранен в возвращенном наборе.
    
    Возвраты:
    неизменный набор, содержащий только указанный объект.
  - singletonList
```
public static <T> List<T> singletonList(T o)
```
    Возвращает неизменный список, содержащий только указанный объект. Возвращенный список сериализуем.
    
    Параметры:
    o - единственный объект, который будет сохранен в возвращенном списке.
    
    Возвраты:
    неизменный список, содержащий только указанный объект.
    С тех пор:
    
    1.3
  - singletonMap
```
public static <K,V> Map<K,V> singletonMap(K key,
                          V value)
```
    Возвращает неизменную карту, отображая только указанный ключ на указанное значение. Возвращенная карта сериализуема.
    
    Параметры:
    key - единственный ключ, который будет сохранен в возвращенной карте.
    value - значение, на которое возвращенная карта отображает key.
    
    Возвраты:
    неизменная карта, содержащая только указанное отображение значения ключа.
    С тех пор:
    
    1.3
  - nCopies
```
public static <T> List<T> nCopies(int n,
                  T o)
```
    Возвращает неизменный список, состоящий из копий n указанного объекта. Недавно выделенный объект данных является крошечным (он содержит единственную ссылку на объект данных). Этот метод полезен в комбинации с методом List.addAll, чтобы вырастить списки. Возвращенный список сериализуем.
    
    Параметры:
    n - число элементов в возвращенном списке.
    o - элемент, чтобы неоднократно появляться в возвращенном списке.
    
    Возвраты:
    неизменный список, состоящий из копий n указанного объекта.
    
    Броски:
    
    IllegalArgumentException - если n < 0
    См. Также:
    List.addAll(Collection), List.addAll(int, Collection)
  - reverseOrder
```
public static <T> Comparator<T> reverseOrder()
```
    Возвращает компаратор, который налагает реверс естественного упорядочивания на наборе объектов, которые реализуют Comparable интерфейс. (Естественное упорядочивание является упорядочиванием, наложенным собственными объектами compareTo метод.) Это включает простой идиоме для того, чтобы сортировать (или поддержать) наборы (или массивы) объектов, которые реализуют Comparable интерфейс в обратном естественном порядке. Например, предположить a массив строк. Затем:
```
          Arrays.sort(a, Collections.reverseOrder());
 
```
    сортирует массив в обратно-лексикографическом (алфавитном) порядке.
    Возвращенный компаратор сериализуем.
    Возвраты:
    Компаратор, который налагает реверс естественного упорядочивания на наборе объектов, которые реализуют интерфейс Comparable.
    См. Также:
    Comparable
  - reverseOrder
```
public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
```
    Возвращает компаратор, который налагает обратное упорядочивание указанного компаратора. Если указанный компаратор null, этот метод эквивалентен reverseOrder() (другими словами это возвращает компаратор, который налагает реверс естественного упорядочивания на наборе объектов, которые реализуют Сопоставимый интерфейс).
    Возвращенный компаратор сериализуем (принятие, что указанный компаратор также сериализуем или null).
    
    Параметры:
    cmp - компаратор, кто упорядочивает, должен быть инвертирован возвращенным компаратором или null
    
    Возвраты:
    Компаратор, который налагает обратное упорядочивание указанного компаратора.
    С тех пор:
    
    1.5
  - перечисление
```
public static <T> Enumeration<T> enumeration(Collection<T> c)
```
    Возвращает перечисление по указанному набору. Это предоставляет функциональной совместимости API наследства, которые требуют перечисления как входной.
    
    Параметры:
    c - набор, для которого должно быть возвращено перечисление.
    
    Возвраты:
    перечисление по указанному набору.
    См. Также:
    Enumeration
  - список
```
public static <T> ArrayList<T> list(Enumeration<T> e)
```
    Возвращает список массива, содержащий элементы, возвращенные указанным перечислением в порядке, они возвращаются перечислением. Этот метод обеспечивает функциональную совместимость между API наследства, которые возвращают перечисления и новые API, которые требуют наборов.
    
    Параметры:
    e - элементы обеспечения перечисления для возвращенного списка массива
    
    Возвраты:
    список массива, содержащий элементы, возвратился указанным перечислением.
    С тех пор:
    
    1.4
    
    См. Также:
    Enumeration, ArrayList
  - частота
```
public static int frequency(Collection<?> c,
            Object o)
```
    Возвращает число элементов в указанном наборе, равном указанному объекту. Более формально, возвращает число элементов e в наборе так, что (o == null ? e == null : o.equals(e)).
    
    Параметры:
    c - набор, в котором можно определить частоту o
    o - объект, частота которого должна быть определена
    
    Броски:
    
    NullPointerException - если c является нулем
    С тех пор:
    
    1.5
  - непересекающийся
```
public static boolean disjoint(Collection<?> c1,
               Collection<?> c2)
```
    Возвраты true если у двух указанных наборов нет никаких элементов вместе.
    Забота должна быть осуществлена, если этот метод используется на наборах, которые не выполняют общий контракт для Collection. Реализации могут выбрать выполнять итерации или по набору и тестировать на включение в другом наборе (или выполнять любое эквивалентное вычисление). Если любой набор использует нестандартный тест равенства (как делает a SortedSet то, упорядочивание которого не является совместимым с, равняется, или набор ключей IdentityHashMap), оба набора должны использовать тот же самый нестандартный тест равенства, или результат этого метода неопределен.
    Забота должна также быть осуществлена при использовании наборов, у которых есть ограничения на элементы, которые они могут содержать. Реализациям набора позволяют выдать исключения для любых элементов включения работы, которые они считают неподходящим. Для абсолютной безопасности указанные наборы должны содержать только элементы, которые являются имеющими право элементами для обоих наборов.
    Отметьте, что допустимо передать тот же самый набор в обоих параметрах, когда метод возвратится true если и только если набор пуст.
    
    Параметры:
    c1 - набор
    c2 - набор
    
    Возвраты:
    true если у двух указанных наборов нет никаких элементов вместе.
    
    Броски:
    
    NullPointerException - если любой набор null.
    
    NullPointerException - если один набор содержит a null элемент и null не имеющий право элемент для другого набора. (дополнительный)
    
    ClassCastException - если один набор содержит элемент, который имеет тип, который является неподходящим для другого набора. (дополнительный)
    С тех пор:
    
    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");
 
```
    Параметры:
    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)
```
    Возвращает набор, поддержанный указанной картой. Получающийся набор выводит на экран то же самое упорядочивание, параллелизм, и показатели производительности как отступающая карта. В основном этот метод фабрики обеспечивает a Set реализация, соответствующая любому Map реализация. Нет никакой потребности использовать этот метод на a Map реализация, у которой уже есть соответствие Set реализация (такой как HashMap или TreeMap).
    Каждый вызов метода на наборе, возвращенном этим методом, приводит точно к одному вызову метода на отступающей карте или ее представлению keySet с одним исключением. Метод addAll реализуется как последовательность вызовов put на отступающей карте.
    Указанная карта должна быть пустой в то время, когда этот метод вызывается, и не должен быть получен доступ непосредственно после этого метода возвраты. Эти условия обеспечиваются, если карта создается пустая, переданная непосредственно к этому методу, и никакая ссылка на карту не сохраняется, как иллюстрировано в следующем фрагменте кода:
```
    Set<Object> weakHashSet = Collections.newSetFromMap(
        new WeakHashMap<Object, Boolean>());
 
```
    Параметры:
    map - отступающая карта
    
    Возвраты:
    набор отступал картой
    
    Броски:
    
    IllegalArgumentException - если map не пуст
    С тех пор:
    
    1.6
  - asLifoQueue
```
public static <T> Queue<T> asLifoQueue(Deque<T> deque)
```
    Возвращает представление a Deque как В обратном порядке (Lifo) Queue. Метод add отображается на push, remove отображается на pop и так далее. Это представление может быть полезным, когда требуется использовать метод, требующий Queue, но Вы нуждаетесь в упорядочивании Lifo.
    Каждый вызов метода на очереди, возвращенной этим методом, приводит точно к одному вызову метода на отступающей двухсторонней очереди с одним исключением. addAll метод реализуется как последовательность addFirst вызовы на отступающей двухсторонней очереди.
    
    Параметры:
    deque - двухсторонняя очередь
    
    Возвраты:
    очередь
    С тех пор:
    
    1.6

Представьте ошибку или функцию
Для дальнейшей ссылки API и документации разработчика, см. Java Документация SE. Та документация содержит более подробные, предназначенные разработчиком описания, с концептуальными краткими обзорами, определениями сроков, обходных решений, и рабочих примеров кода.
Авторское право © 1993, 2011, Oracle и/или его филиалы. Все права защищены.

Наборы класса

Полевая Сводка

Сводка метода

Методы java.lang унаследованный от класса. Объект

Полевая Деталь

EMPTY_SET

EMPTY_LIST

EMPTY_MAP

Деталь метода

вид

вид

binarySearch

binarySearch

реверс

перестановка

перестановка

подкачка

заливка

копия

минута

минута

максимальный

максимальный

вращаться

replaceAll

indexOfSubList

lastIndexOfSubList

unmodifiableCollection

unmodifiableSet

unmodifiableSortedSet

unmodifiableList

unmodifiableMap

unmodifiableSortedMap

synchronizedCollection

synchronizedSet

synchronizedSortedSet

synchronizedList

synchronizedMap

synchronizedSortedMap

checkedCollection

checkedSet

checkedSortedSet

checkedList

checkedMap

checkedSortedMap

emptyIterator

emptyListIterator

emptyEnumeration

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

emptyList

emptyMap

одиночный элемент

singletonList

singletonMap

nCopies

reverseOrder

reverseOrder

перечисление

список

частота

непересекающийся

addAll

newSetFromMap

asLifoQueue