Spec-Zone .ru
спецификации, руководства, описания, API
|
public class Collections extends Object
Методы этого class весь бросок NullPointerException, если наборы или объекты class, предоставленные им, являются нулем.
Документация для полиморфных алгоритмов, содержавшихся в этом class обычно, включает краткое описание реализации. Такие описания должны быть расценены, как реализация отмечает, а не отделяется спецификации. Конструкторы должны не стесняться заменять другими алгоритмами, пока сама спецификация придерживается к. (Например, алгоритм, используемый sort, не должен быть сортировкой с объединением, но это действительно должно быть устойчиво.)
"Разрушительные" алгоритмы, содержавшиеся в этом class, то есть, алгоритмы, которые изменяют набор, на котором они работают, определяются, чтобы бросить UnsupportedOperationException, если набор не поддерживает соответствующую мутацию, примитивную (s), такой как метод set. Эти алгоритмы, но не обязаны, может выдать это исключение, если вызов не имел бы никакого эффекта на набор. Например, вызов метода sort в неподдающемся изменению списке, который уже сортируется, может или, возможно, не бросает UnsupportedOperationException.
Этот class является элементом Платформы Наборов Java.
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)
|
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> 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()
Возвращает 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 <E> SortedSet<E> |
emptySortedSet()
Возвращает пустой сортированный (неизменный) набор.
|
static <T> Enumeration<T> |
enumeration(Collection<T> c)
Возвращает перечисление по указанному набору.
|
static <T> void |
fill(List<? super T> list, T obj)
Замены все элементы указанного списка с указанным элементом.
|
static int |
frequency(Collection<?> c, Object o)
Возвращает число элементов в указанном наборе, равном указанному объекту.
|
static int |
indexOfSubList(List<?> source, List<?> target)
Возвращает стартовую позицию первого возникновения указанного целевого списка в пределах указанного исходного списка, или-1, если нет такого возникновения.
|
static int |
lastIndexOfSubList(List<?> source, List<?> target)
Возвращает стартовую позицию последнего вхождения указанного целевого списка в пределах указанного исходного списка, или-1, если нет такого возникновения.
|
static <T> ArrayList<T> |
list(Enumeration<T> e)
Возвращает список массива, содержащий элементы, возвращенные указанным перечислением в порядке, они возвращаются перечислением.
|
static <T extends Object & Comparable<? super T>> |
max(Collection<? extends T> coll)
Возвращает максимальный элемент данного набора, согласно естественному упорядочиванию его элементов.
|
static <T> T |
max(Collection<? extends T> coll, Comparator<? super T> comp)
Возвращает максимальный элемент данного набора, согласно порядку, вызванному указанным компаратором.
|
static <T extends Object & Comparable<? super 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>> |
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)
Возвращает неподдающееся изменению представление указанного сортированного набора.
|
public static final Set EMPTY_SET
emptySet()
public static final List EMPTY_LIST
emptyList()
public static final Map EMPTY_MAP
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
Эта реализация выводит указанный список в массив, сортирует массив, и выполняет итерации по списку, сбрасывающему каждый элемент от соответствующей позиции в массиве. Это избегает журнала n2 (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
Эта реализация выводит указанный список в массив, сортирует массив, и выполняет итерации по списку, сбрасывающему каждый элемент от соответствующей позиции в массиве. Это избегает журнала n2 (n) производительность, которая следовала бы из попытки сортировать связанный список на месте.
list
- список, который будет сортирован.c
- компаратор, чтобы определить порядок списка. A null
значение указывает, что естественное упорядочивание элементов должно использоваться.ClassCastException
- если список содержит элементы, которые не являются взаимно сопоставимым использованием указанного компаратора.UnsupportedOperationException
- если список-iterator указанного списка не поддерживает set
работа.IllegalArgumentException
- (дополнительный), если компаратор, как находят, нарушает Comparator
контрактpublic static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
sort(List)
метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если список содержит многократные элементы, равные указанному объекту, нет никакой гарантии, которой будет найден. Этот метод выполняет в журнале (n) время для списка "произвольного доступа" (который обеспечивает "около постоянного времени" позиционный доступ). Если указанный список не реализует RandomAccess
взаимодействуйте через интерфейс и является большим, этот метод сделает iterator-на-основе двоичный поиск, который выполняет O (n) обходы ссылки, и O (зарегистрируйте n), сравнения элемента.
list
- список, который будет искаться.key
- ключ, который будет разыскиваться.ClassCastException
- если список содержит элементы, которые не взаимно сопоставимы (например, строки и целые числа), или ключ поиска не взаимно сопоставим с элементами списка.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 указывает, что естественное упорядочивание элементов должно использоваться.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 ()).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)
Этот метод выполняет итерации по всему набору, следовательно требуется время, пропорциональное размеру набора.
coll
- набор, минимальный элемент которого должен быть определен.ClassCastException
- если набор содержит элементы, которые не взаимно сопоставимы (например, строки и целые числа).NoSuchElementException
- если набор пуст.Comparable
public static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
Этот метод выполняет итерации по всему набору, следовательно требуется время, пропорциональное размеру набора.
coll
- набор, минимальный элемент которого должен быть определен.comp
- компаратор, с которым можно определить минимальный элемент. Значение null указывает, что естественное упорядочивание элементов должно использоваться.ClassCastException
- если набор содержит элементы, которые не являются взаимно сопоставимым использованием указанного компаратора.NoSuchElementException
- если набор пуст.Comparable
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
Этот метод выполняет итерации по всему набору, следовательно требуется время, пропорциональное размеру набора.
coll
- набор, максимальный элемент которого должен быть определен.ClassCastException
- если набор содержит элементы, которые не взаимно сопоставимы (например, строки и целые числа).NoSuchElementException
- если набор пуст.Comparable
public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
Этот метод выполняет итерации по всему набору, следовательно требуется время, пропорциональное размеру набора.
coll
- набор, максимальный элемент которого должен быть определен.comp
- компаратор, с которым можно определить максимальный элемент. Значение null указывает, что естественное упорядочивание элементов должно использоваться.ClassCastException
- если набор содержит элементы, которые не являются взаимно сопоставимым использованием указанного компаратора.NoSuchElementException
- если набор пуст.Comparable
public static void rotate(List<?> list, int distance)
Например, предположите 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.public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
list
- список, в котором должна произойти замена.oldVal
- старое значение, которое будет заменено.newVal
- новое значение, которым должен быть заменен oldVal.UnsupportedOperationException
- если указанный список или его список-iterator не поддерживают работу set.public static int indexOfSubList(List<?> source, List<?> target)
Эта реализация использует метод "грубой силы" сканирования по исходному списку, ища соответствие с целью в каждом расположении поочередно.
source
- список, в котором можно искать первое возникновение target.target
- список, чтобы искать как подсписок source.public static int lastIndexOfSubList(List<?> source, List<?> target)
Эта реализация использует метод "грубой силы" итерации по исходному списку, ища соответствие с целью в каждом расположении поочередно.
source
- список, в котором можно искать последнее вхождение target.target
- список, чтобы искать как подсписок source.public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c)
Возвращенный набор не передает хэш-код и равняется операциям через отступающему набору, но полагается на методы equals И hashCode Object. Это необходимо, чтобы сохранить контракты этих операций в случае, что отступающий набор является набором или списком.
Возвращенный набор будет сериализуем, если указанный набор будет сериализуем.
c
- набор, для которого должно быть возвращено неподдающееся изменению представление.public static <T> Set<T> unmodifiableSet(Set<? extends T> s)
Возвращенный набор будет сериализуем, если указанный набор будет сериализуем.
s
- набор, для которого должно быть возвращено неподдающееся изменению представление.public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)
Возвращенный сортированный набор будет сериализуем, если указанный сортированный набор будет сериализуем.
s
- сортированный набор, для которого должно быть возвращено неподдающееся изменению представление.public static <T> List<T> unmodifiableList(List<? extends T> list)
Возвращенный список будет сериализуем, если указанный список будет сериализуем. Точно так же возвращенный список реализует RandomAccess
если указанный список делает.
list
- список, для которого должно быть возвращено неподдающееся изменению представление.public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m)
Возвращенная карта будет сериализуема, если указанная карта будет сериализуема.
m
- карта, для которой должно быть возвращено неподдающееся изменению представление.public static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m)
Возвращенная сортированная карта будет сериализуема, если указанная сортированная карта будет сериализуема.
m
- сортированная карта, для которой должно быть возвращено неподдающееся изменению представление.public static <T> Collection<T> synchronizedCollection(Collection<T> c)
Обязательно, чтобы пользователь вручную синхронизировался на возвращенном наборе, пересекая это через Iterator
или Spliterator
:
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
's равняется и методы хэш-кода. Это необходимо, чтобы сохранить контракты этих операций в случае, что отступающий набор является набором или списком.
Возвращенный набор будет сериализуем, если указанный набор будет сериализуем.
c
- набор, который будет "обернут" в синхронизируемый набор.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
- набор, который будет "обернут" в синхронизируемый набор.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
- сортированный набор, который будет "обернут" в синхронизируемый сортированный набор.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
- список, который будет "обернут" в синхронизируемый список.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
- карта, которая будет "обернута" в синхронизируемую карту.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
- сортированная карта, которая будет "обернута" в синхронизируемую сортированную карту.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
разрешается содержатьpublic static <E> Queue<E> checkedQueue(Queue<E> queue, Class<E> type)
ClassCastException
. Принятие очереди не содержит неправильно введенных элементов до тех пор, пока динамически безопасное с точки зрения типов представление сгенерировано, и что весь последующий доступ к очереди имеет место посредством представления, гарантируется, что очередь не может содержать неправильно введенный элемент. Обсуждение использования динамически безопасных с точки зрения типов представлений может быть найдено в документации для checkedCollection
метод.
Возвращенная очередь будет сериализуема, если указанная очередь будет сериализуема.
С тех пор null
как полагают, значение любого ссылочного типа, возвращенная очередь разрешает вставку null
элементы всякий раз, когда отступающая очередь делает.
queue
- очередь, для которой должно быть возвращено динамически безопасное с точки зрения типов представлениеtype
- тип элемента это queue
разрешается содержатьpublic static <E> Set<E> checkedSet(Set<E> s, Class<E> type)
ClassCastException
. Принятие набора не содержит неправильно введенных элементов до тех пор, пока динамически безопасное с точки зрения типов представление сгенерировано, и что весь последующий доступ к набору имеет место посредством представления, гарантируется, что набор не может содержать неправильно введенный элемент. Обсуждение использования динамически безопасных с точки зрения типов представлений может быть найдено в документации для checkedCollection
метод.
Возвращенный набор будет сериализуем, если указанный набор будет сериализуем.
С тех пор null
как полагают, значение любого ссылочного типа, возвращенный набор разрешает вставку нулевых элементов всякий раз, когда набор поддержки делает.
s
- набор, для которого должно быть возвращено динамически безопасное с точки зрения типов представлениеtype
- тип элемента это s
разрешается содержатьpublic static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, Class<E> type)
ClassCastException
. Принятие сортированного набора не содержит неправильно введенных элементов до тех пор, пока динамически безопасное с точки зрения типов представление сгенерировано, и что весь последующий доступ к сортированному набору имеет место посредством представления, гарантируется, что сортированный набор не может содержать неправильно введенный элемент. Обсуждение использования динамически безопасных с точки зрения типов представлений может быть найдено в документации для checkedCollection
метод.
Возвращенный сортированный набор будет сериализуем, если указанный сортированный набор будет сериализуем.
С тех пор null
как полагают, значение любого ссылочного типа, возвращенный сортированный набор разрешает вставку нулевых элементов всякий раз, когда поддержка сортированный набор делает.
s
- сортированный набор, для которого должно быть возвращено динамически безопасное с точки зрения типов представлениеtype
- тип элемента это s
разрешается содержатьpublic static <E> List<E> checkedList(List<E> list, Class<E> type)
ClassCastException
. Принятие списка не содержит неправильно введенных элементов до тех пор, пока динамически безопасное с точки зрения типов представление сгенерировано, и что весь последующий доступ к списку имеет место посредством представления, гарантируется, что список не может содержать неправильно введенный элемент. Обсуждение использования динамически безопасных с точки зрения типов представлений может быть найдено в документации для checkedCollection
метод.
Возвращенный список будет сериализуем, если указанный список будет сериализуем.
С тех пор null
как полагают, значение любого ссылочного типа, возвращенный список разрешает вставку нулевых элементов всякий раз, когда отступающий список делает.
list
- список, для которого должно быть возвращено динамически безопасное с точки зрения типов представлениеtype
- тип элемента это list
разрешается содержать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
разрешается содержать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
разрешается содержатьpublic static <T> Iterator<T> emptyIterator()
hasNext
всегда возвраты false
. next
всегда броски NoSuchElementException
. remove
всегда броски IllegalStateException
. Реализации этого метода разрешаются, но не требуются, чтобы возвратить тот же самый объект из многократных вызовов.
public static <T> ListIterator<T> emptyListIterator()
hasNext
и hasPrevious
всегда возвращайтесь false
. next
и previous
всегда бросок NoSuchElementException
. remove
и set
всегда бросок IllegalStateException
. add
всегда броски UnsupportedOperationException
. nextIndex
всегда возвраты 0
. previousIndex
всегда возвраты -1
. Реализации этого метода разрешаются, но не требуются, чтобы возвратить тот же самый объект из многократных вызовов.
public static <T> Enumeration<T> emptyEnumeration()
hasMoreElements
всегда возвраты false
. nextElement
всегда броски NoSuchElementException
. Реализации этого метода разрешаются, но не требуются, чтобы возвратить тот же самый объект из многократных вызовов.
public static final <T> Set<T> emptySet()
Этот пример иллюстрирует безопасный с точки зрения типов способ получить пустое множество:
Set<String> s = Collections.emptySet();Примечание реализации: Реализации этого метода не должны создать отдельный объект Set для каждого вызова. Используя этот метод, вероятно, будет иметь сопоставимую стоимость для использования подобно-именованного поля. (В отличие от этого метода, поле не обеспечивает безопасность типов.)
EMPTY_SET
public static final <E> SortedSet<E> emptySortedSet()
Этот пример иллюстрирует безопасный с точки зрения типов способ получить пустой сортированный набор:
SortedSet<String> s = Collections.emptySortedSet();Примечание реализации: Реализации этого метода не должны создать отдельный объект SortedSet для каждого вызова.
public static final <T> List<T> emptyList()
Этот пример иллюстрирует безопасный с точки зрения типов способ получить пустой список:
List<String> s = Collections.emptyList();Примечание реализации: Реализации этого метода не должны создать отдельный объект List для каждого вызова. Используя этот метод, вероятно, будет иметь сопоставимую стоимость для использования подобно-именованного поля. (В отличие от этого метода, поле не обеспечивает безопасность типов.)
EMPTY_LIST
public static final <K,V> Map<K,V> emptyMap()
Этот пример иллюстрирует безопасный с точки зрения типов способ получить пустое множество:
Map<String, Date> s = Collections.emptyMap();Примечание реализации: Реализации этого метода не должны создать отдельный объект Map для каждого вызова. Используя этот метод, вероятно, будет иметь сопоставимую стоимость для использования подобно-именованного поля. (В отличие от этого метода, поле не обеспечивает безопасность типов.)
EMPTY_MAP
public static <T> Set<T> singleton(T o)
o
- единственный объект, который будет сохранен в возвращенном наборе.public static <T> List<T> singletonList(T o)
o
- единственный объект, который будет сохранен в возвращенном списке.public static <K,V> Map<K,V> singletonMap(K key, V value)
key
- единственный ключ, который будет сохранен в возвращенной карте.value
- значение, на которое возвращенная карта отображает key.public static <T> List<T> nCopies(int n, T o)
n
- число элементов в возвращенном списке.o
- элемент, чтобы неоднократно появляться в возвращенном списке.IllegalArgumentException
- если n < 0
List.addAll(Collection)
, List.addAll(int, Collection)
public static <T> Comparator<T> reverseOrder()
Comparable
интерфейс. (Естественное упорядочивание является упорядочиванием, наложенным собственными объектами compareTo
метод.) Это включает простой идиоме для того, чтобы сортировать (или поддержать) наборы (или массивы) объектов, которые реализуют Comparable
интерфейс в обратном естественном порядке. Например, предположить a
массив строк. Затем: Arrays.sort(a, Collections.reverseOrder());сортирует массив в обратно-лексикографическом (алфавитном) порядке.
Возвращенный компаратор сериализуем.
Comparable
public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
null
, этот метод эквивалентен reverseOrder()
(другими словами это возвращает компаратор, который налагает реверс естественного упорядочивания на наборе объектов, которые реализуют Сопоставимый интерфейс). Возвращенный компаратор сериализуем (принятие, что указанный компаратор также сериализуем или null
).
cmp
- компаратор, кто упорядочивает, должен быть инвертирован возвращенным компаратором или null
public static <T> Enumeration<T> enumeration(Collection<T> c)
c
- набор, для которого должно быть возвращено перечисление.Enumeration
public static <T> ArrayList<T> list(Enumeration<T> e)
e
- элементы обеспечения перечисления для возвращенного списка массиваEnumeration
, ArrayList
public static int frequency(Collection<?> c, Object o)
c
- набор, в котором можно определить частоту oo
- объект, частота которого должна быть определенаNullPointerException
- если c является нулемpublic static boolean disjoint(Collection<?> c1, Collection<?> c2)
true
если у двух указанных наборов нет никаких элементов вместе. Забота должна быть осуществлена, если этот метод используется на наборах, которые не выполняют общий контракт для Collection
. Реализации могут выбрать выполнять итерации или по набору и тестировать на включение в другом наборе (или выполнять любое эквивалентное вычисление). Если любой набор использует нестандартный тест равенства (как делает a SortedSet
то, упорядочивание которого не является совместимым с, равняется, или набор ключей IdentityHashMap
), оба набора должны использовать тот же самый нестандартный тест равенства, или результат этого метода неопределен.
Забота должна также быть осуществлена при использовании наборов, у которых есть ограничения на элементы, которые они могут содержать. Реализациям набора позволяют выдать исключения для любых элементов включения работы, которые они считают неподходящим. Для абсолютной безопасности указанные наборы должны содержать только элементы, которые являются имеющими право элементами для обоих наборов.
Отметьте, что допустимо передать тот же самый набор в обоих параметрах, когда метод возвратится true
если и только если набор пуст.
c1
- наборc2
- наборtrue
если у двух указанных наборов нет никаких элементов вместе.NullPointerException
- если любой набор null
.NullPointerException
- если один набор содержит a null
элемент и null
не имеющий право элемент для другого набора. (дополнительный)ClassCastException
- если один набор содержит элемент, который имеет тип, который является неподходящим для другого набора. (дополнительный)@SafeVarargs public static <T> boolean addAll(Collection<? super T> c, T... elements)
Когда элементы определяются индивидуально, этот метод обеспечивает удобный способ добавить несколько элементов к существующему набору:
Collections.addAll(flavors, "Peaches 'n Plutonium", "Rocky Racoon");
c
- набор, в который elements должны быть вставленыelements
- элементы, чтобы вставить в cUnsupportedOperationException
- если c не поддерживает работу addNullPointerException
- если elements содержит одно или более нулевых значений, и c не разрешает нулевые элементы, или если c или elements является nullIllegalArgumentException
- если некоторое свойство значения в elements препятствует тому, чтобы это было добавлено к cCollection.addAll(Collection)
public static <E> Set<E> newSetFromMap(Map<E,Boolean> map)
Set
реализация, соответствующая любому Map
реализация. Нет никакой потребности использовать этот метод на a Map
реализация, у которой уже есть соответствие Set
реализация (такой как HashMap
или TreeMap
). Каждый вызов метода на наборе, возвращенном этим методом, приводит точно к одному вызову метода на отступающей карте или ее представлению keySet с одним исключением. Метод addAll реализуется как последовательность вызовов put на отступающей карте.
Указанная карта должна быть пустой в то время, когда этот метод вызывается, и не должен быть получен доступ непосредственно после этого метода возвраты. Эти условия обеспечиваются, если карта создается пустая, переданная непосредственно к этому методу, и никакая ссылка на карту не сохраняется, как иллюстрировано в следующем фрагменте кода:
Set<Object> weakHashSet = Collections.newSetFromMap( new WeakHashMap<Object, Boolean>());
map
- отступающая картаIllegalArgumentException
- если map не пустpublic static <T> Queue<T> asLifoQueue(Deque<T> deque)
Deque
как В обратном порядке (Lifo) Queue
. Метод add отображается на push, remove отображается на pop и так далее. Это представление может быть полезным, когда требуется использовать метод, требующий Queue, но Вы нуждаетесь в упорядочивании Lifo. Каждый вызов метода на очереди, возвращенной этим методом, приводит точно к одному вызову метода на отступающей двухсторонней очереди с одним исключением. addAll
метод реализуется как последовательность addFirst
вызовы на отступающей двухсторонней очереди.
deque
- двухсторонняя очередь
Для дальнейшей ссылки API и документации разработчика, см. Java Документация SE. Та документация содержит более подробные, предназначенные разработчиком описания, с концептуальными краткими обзорами, определениями сроков, обходных решений, и рабочих примеров кода.
Авторское право © 1993, 2013, Oracle и/или его филиалы. Все права защищены.
Проект сборка-b92