Класс Collections

public static final Set EMPTY_SET

public static final List EMPTY_LIST

public static final Map EMPTY_MAP

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

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

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

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

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

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

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

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

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

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

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

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

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

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

public static void reverse(List<?> list)

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

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

public static void shuffle(List<?> list)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Collections.rotate(list.subList(j, k+1), -1);

Чтобы конкретизировать, предположим, что list содержит [a, b, c, d, e]. Чтобы переместить элемент с индексом 1 (b) вперёд на две позиции, выполните следующий вызов:

Collections.rotate(l.subList(1, 4), -1);

Результирующий список: [a, c, d, b, e].

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Collection c = Collections.synchronizedCollection(myCollection);
     ...
  synchronized (c) {
      Iterator i = c.iterator(); // Must be in the synchronized block
      while (i.hasNext())
         foo(i.next());
  }

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

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

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

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

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

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

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

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

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

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

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

Необходимо, чтобы пользователь вручную синхронизировал возвращённое навигационное множество при итерировании по нему или любым его subSet, headSet, или tailSet представлениям.

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

или:

NavigableSet s = Collections.synchronizedNavigableSet(new TreeSet());
  NavigableSet s2 = s.headSet(foo, true);
      ...
  synchronized (s) {  // Note: s, not s2!!!
      Iterator i = s2.iterator(); // Must be in the synchronized block
      while (i.hasNext())
          foo(i.next());
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

NavigableMap m = Collections.synchronizedNavigableMap(new TreeMap());
      ...
  Set s = m.keySet();  // Needn't be in synchronized block
      ...
  synchronized (m) {  // Synchronizing on m, not s!
      Iterator i = s.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }

или:

NavigableMap m = Collections.synchronizedNavigableMap(new TreeMap());
  NavigableMap m2 = m.subMap(foo, true, bar, false);
      ...
  Set s2 = m2.keySet();  // Needn't be in synchronized block
      ...
  synchronized (m) {  // Synchronizing on m, not m2 or s2!
      Iterator i = s.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }

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

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

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

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

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

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

Collection<String> c = new HashSet<>();

можно временно заменить этим:

Collection<String> c = Collections.checkedCollection(
         new HashSet<>(), String.class);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@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");

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

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

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

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

Set<Object> weakHashSet = Collections.newSetFromMap(
        new WeakHashMap<Object, Boolean>());

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

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

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