java.lang.Object

java.util.Collections

public class Collections extends Object

这个类仅包含操作或返回集合的静态方法。它包含在集合上操作的多态算法，“包装器”，它们返回由指定集合支持的新集合，以及其他一些杂项。

此类的所有方法如果提供给它们的集合或类对象为null，则会抛出NullPointerException。

此类中包含的多态算法的文档通常包括对实现的简要描述。这些描述应被视为实现注释，而不是规范的一部分。实现者可以随意替换其他算法，只要遵守规范本身即可。（例如，sort使用的算法不一定要是归并排序，但必须是稳定的。）

此类中包含的“破坏性”算法，即修改其操作的集合的算法，如果集合不支持适当的变异原语（例如set方法），则指定会抛出UnsupportedOperationException。如果调用对集合没有影响，则这些算法可能会，但不一定会抛出此异常。例如，在已排序的不可修改列表上调用sort方法可能会或可能不会抛出UnsupportedOperationException。

此类是Java集合框架的成员。

自从:

1.2

参见:

Field Summary

Fields

Modifier and Type

Field

Description

static final List

EMPTY_LIST

空列表（不可变）。

static final Map

EMPTY_MAP

空映射（不可变）。

static final Set

EMPTY_SET

空集合（不可变）。
Method Summary

Modifier and Type

Method

Description

static <T> boolean

addAll(Collection<? super T> c, T... elements)

将所有指定的元素添加到指定的集合中。

static <T> Queue<T>

asLifoQueue(Deque<T> deque)

将Deque的视图作为后进先出（Lifo）Queue返回。

static <T> int

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

使用二分搜索算法在指定列表中搜索指定对象。

static <T> int

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

使用二分搜索算法在指定列表中搜索指定对象。

static <E> Collection<E>

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

返回指定集合的动态类型安全视图。

static <E> List<E>

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

返回指定列表的动态类型安全视图。

static <K, V> Map<K,V>

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

返回指定映射的动态类型安全视图。

static <K, V> NavigableMap<K,V>

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

返回指定可导航映射的动态类型安全视图。

static <E> NavigableSet<E>

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

返回指定可导航集的动态类型安全视图。

static <E> Queue<E>

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

返回指定队列的动态类型安全视图。

static <E> Set<E>

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

返回指定集合的动态类型安全视图。

static <K, V> SortedMap<K,V>

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

返回指定排序映射的动态类型安全视图。

static <E> SortedSet<E>

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

返回指定排序集的动态类型安全视图。

static <T> void

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

将一个列表中的所有元素复制到另一个列表中。

static boolean

disjoint(Collection<?> c1, Collection<?> c2)

如果两个指定的集合没有共同元素，则返回true。

static <T> Enumeration<T>

emptyEnumeration()

返回一个没有元素的枚举。

static <T> Iterator<T>

emptyIterator()

返回一个没有元素的迭代器。

static final <T> List<T>

emptyList()

返回一个空列表（不可变）。

static <T> ListIterator<T>

emptyListIterator()

返回一个没有元素的列表迭代器。

static final <K, V> Map<K,V>

emptyMap()

返回一个空映射（不可变）。

static final <K, V> NavigableMap<K,V>

emptyNavigableMap()

返回一个空可导航映射（不可变）。

static <E> NavigableSet<E>

emptyNavigableSet()

返回一个空可导航集（不可变）。

static final <T> Set<T>

emptySet()

返回一个空集合（不可变）。

static final <K, V> SortedMap<K,V>

emptySortedMap()

返回一个空排序映射（不可变）。

static <E> SortedSet<E>

emptySortedSet()

返回一个空排序集（不可变）。

static <T> Enumeration<T>

enumeration(Collection<T> c)

返回指定集合上的枚举。

static <T> void

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

用指定元素替换指定列表的所有元素。

static int

frequency(Collection<?> c, Object o)

返回指定集合中与指定对象相等的元素数。

static int

indexOfSubList(List<?> source, List<?> target)

返回指定源列表中指定目标列表的第一次出现的起始位置，如果没有这样的出现则返回-1。

static int

lastIndexOfSubList(List<?> source, List<?> target)

返回指定源列表中指定目标列表的最后一次出现的起始位置，如果没有这样的出现则返回-1。

static <T> ArrayList<T>

list(Enumeration<T> e)

返回包含指定枚举器按其返回顺序返回的元素的数组列表。

static <T extends Object & Comparable<? super T>> T

max(Collection<? extends T> coll)

返回给定集合的最大元素，根据其元素的自然顺序。

static <T> T

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

返回给定集合的最大元素，根据指定比较器引起的顺序。

static <T extends Object & Comparable<? super T>> T

min(Collection<? extends T> coll)

返回给定集合的最小元素，根据其元素的自然顺序。

static <T> T

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

返回给定集合的最小元素，根据指定比较器引起的顺序。

static <T> List<T>

nCopies(int n, T o)

返回由指定对象的n个副本组成的不可变列表。

static <E> SequencedSet<E>

newSequencedSetFromMap(SequencedMap<E,Boolean> map)

返回由指定映射支持的序列化集。

static <E> Set<E>

newSetFromMap(Map<E,Boolean> map)

返回由指定映射支持的集合。

static <T> boolean

replaceAll(List<T> list, T oldVal, T newVal)

用另一个指定值替换列表中一个指定值的所有出现。

static void

reverse(List<?> list)

颠倒指定列表中元素的顺序。

static <T> Comparator<T>

reverseOrder()

返回一个比较器，对实现Comparable接口的对象集合施加自然顺序的反向排序。

static <T> Comparator<T>

reverseOrder(Comparator<T> cmp)

返回一个施加指定比较器的反向排序的比较器。

static void

rotate(List<?> list, int distance)

将指定列表中的元素按指定距离旋转。

static void

shuffle(List<?> list)

使用默认随机源随机排列指定列表。

static void

shuffle(List<?> list, Random rnd)

使用指定随机源随机排列指定列表。

static void

shuffle(List<?> list, RandomGenerator rnd)

使用指定随机源随机排列指定列表。

static <T> Set<T>

singleton(T o)

返回仅包含指定对象的不可变集合。

static <T> List<T>

singletonList(T o)

返回仅包含指定对象的不可变列表。

static <K, V> Map<K,V>

singletonMap(K key, V value)

返回不可变映射，仅将指定键映射到指定值。

static <T extends Comparable<? super T>> void

sort(List<T> list)

根据其元素的自然顺序，将指定列表按升序排序。

static <T> void

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

根据指定比较器引起的顺序对指定列表进行排序。

static void

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

交换指定列表中指定位置的元素。

static <T> Collection<T>

synchronizedCollection(Collection<T> c)

返回由指定集合支持的同步（线程安全）集合。

static <T> List<T>

synchronizedList(List<T> list)

返回由指定列表支持的同步（线程安全）列表。

static <K, V> Map<K,V>

synchronizedMap(Map<K,V> m)

返回由指定映射支持的同步（线程安全）映射。

static <K, V> NavigableMap<K,V>

synchronizedNavigableMap(NavigableMap<K,V> m)

返回由指定可导航映射支持的同步（线程安全）可导航映射。

static <T> NavigableSet<T>

synchronizedNavigableSet(NavigableSet<T> s)

返回由指定可导航集支持的同步（线程安全）可导航集。

static <T> Set<T>

synchronizedSet(Set<T> s)

返回由指定集合支持的同步（线程安全）集合。

static <K, V> SortedMap<K,V>

synchronizedSortedMap(SortedMap<K,V> m)

返回由指定排序映射支持的同步（线程安全）排序映射。

static <T> SortedSet<T>

synchronizedSortedSet(SortedSet<T> s)

返回由指定排序集支持的同步（线程安全）排序集。

static <T> Collection<T>

unmodifiableCollection(Collection<? extends T> c)

返回指定集合的不可修改视图。

static <T> List<T>

unmodifiableList(List<? extends T> list)

返回指定列表的不可修改视图。

static <K, V> Map<K,V>

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

返回指定映射的不可修改视图。

static <K, V> NavigableMap<K,V>

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

返回指定可导航映射的不可修改视图。

static <T> NavigableSet<T>

unmodifiableNavigableSet(NavigableSet<T> s)

返回指定可导航集的不可修改视图。

static <T> SequencedCollection<T>

unmodifiableSequencedCollection(SequencedCollection<? extends T> c)

返回指定SequencedCollection的不可修改视图。

static <K, V> SequencedMap<K,V>

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

返回指定SequencedMap的不可修改视图。

static <T> SequencedSet<T>

unmodifiableSequencedSet(SequencedSet<? extends T> s)

返回指定SequencedSet的不可修改视图。

static <T> Set<T>

unmodifiableSet(Set<? extends T> s)

返回指定集合的不可修改视图。

static <K, V> SortedMap<K,V>

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

返回指定排序映射的不可修改视图。

static <T> SortedSet<T>

unmodifiableSortedSet(SortedSet<T> s)

返回指定排序集的不可修改视图。

Methods declared in class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details
- EMPTY_SET
  
  public static final Set EMPTY_SET
  
  空集合（不可变）。此集合可序列化。
  参见:
  
  emptySet()
- EMPTY_LIST
  
  public static final List EMPTY_LIST
  
  空列表（不可变）。此列表可序列化。
  参见:
  
  emptyList()
- EMPTY_MAP
  
  public static final Map EMPTY_MAP
  
  空映射（不可变）。此映射可序列化。
  自从:
  
  1.3
  
  参见:
  
  emptyMap()
Method Details
- sort
  
  public static <T extends Comparable<? super T>> void sort(List<T> list)
  
  根据其元素的自然顺序，将指定列表按升序排序。列表中的所有元素必须实现Comparable接口。此外，列表中的所有元素必须是相互可比较的（即，对于列表中的任何元素e1和e2，e1.compareTo(e2)不能对任何元素e1和e2抛出ClassCastException）。
  此排序保证是稳定的：相等的元素不会因排序而重新排序。
  
  指定的列表必须是可修改的，但不一定是可调整大小的。
  实现注意事项:
  
  此实现延迟到使用指定列表和null比较器的List.sort(Comparator)方法。
  
  类型参数:
  
  T - 列表中对象的类
  
  参数:
  
  list - 要排序的列表。
  
  抛出:
  
  ClassCastException - 如果列表包含不是相互可比较的元素（例如，字符串和整数）。
  
  UnsupportedOperationException - 如果指定列表的列表迭代器不支持set操作。
  
  IllegalArgumentException - （可选）如果实现检测到列表元素的自然顺序违反了Comparable合同
  
  参见:
  
  List.sort(Comparator)
- sort
  
  public static <T> void sort(List<T> list, Comparator<? super T> c)
  
  根据指定比较器引起的顺序对列表进行排序。列表中的所有元素必须使用指定比较器进行相互比较（即，对于列表中的任何元素e1和e2，c.compare(e1, e2)不能抛出ClassCastException）。
  此排序保证是稳定的：相等的元素不会因排序而重新排序。
  
  指定的列表必须是可修改的，但不一定是可调整大小的。
  实现注意事项:
  
  此实现延迟到使用指定列表和比较器的List.sort(Comparator)方法。
  
  类型参数:
  
  T - 列表中对象的类
  
  参数:
  
  list - 要排序的列表。
  
  c - 用于确定列表顺序的比较器。 null值表示应使用元素的自然顺序。
  
  抛出:
  
  ClassCastException - 如果列表包含使用指定比较器不是相互可比较的元素。
  
  UnsupportedOperationException - 如果指定列表的列表迭代器不支持set操作。
  
  IllegalArgumentException - （可选）如果发现比较器违反了Comparator合同
  
  参见:
  
  List.sort(Comparator)
- binarySearch
  
  public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
  
  使用二分搜索算法在指定列表中搜索指定对象。在进行此调用之前，列表必须根据其元素的自然顺序（如sort(List)方法）按升序排序。如果未排序，则结果是未定义的。如果列表包含多个等于指定对象的元素，则不能保证找到哪个。
  对于“随机访问”列表（提供近似恒定时间位置访问），此方法运行时间为log(n)。如果指定列表不实现RandomAccess接口并且很大，则此方法将执行基于迭代器的二分搜索，执行O(n)链接遍历和O(log n)元素比较。
  
  类型参数:
  
  T - 列表中对象的类
  
  参数:
  
  list - 要搜索的列表。
  
  key - 要搜索的关键字。
  
  返回:
  
  如果搜索键包含在列表中，则返回搜索键的索引；否则返回(-(插入点) - 1)。 插入点被定义为将关键字插入列表的位置：大于关键字的第一个元素的索引，或者如果列表中的所有元素都小于指定的关键字，则为list.size()。请注意，这保证了仅当找到关键字时返回值将是>= 0。
  
  抛出:
  
  ClassCastException - 如果列表包含不是使用指定比较器相互可比较的元素（例如，字符串和整数），或者搜索键与列表元素不是使用此比较器相互可比较。
- binarySearch
  
  public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
  
  使用二分搜索算法在指定列表中搜索指定对象。在进行此调用之前，列表必须根据指定比较器（如sort(List, Comparator)方法）按升序排序。如果未排序，则结果是未定义的。如果列表包含多个等于指定对象的元素，则不能保证找到哪个。
  对于“随机访问”列表（提供近似恒定时间位置访问），此方法运行时间为log(n)。如果指定列表不实现RandomAccess接口并且很大，则此方法将执行基于迭代器的二分搜索，执行O(n)链接遍历和O(log n)元素比较。
  
  类型参数:
  
  T - 列表中对象的类
  
  参数:
  
  list - 要搜索的列表。
  
  key - 要搜索的关键字。
  
  c - 用于对列表排序的比较器。 null值表示应使用元素的自然顺序。
  
  返回:
  
  如果搜索键包含在列表中，则返回搜索键的索引；否则返回(-(插入点) - 1)。 插入点被定义为将关键字插入列表的位置：大于关键字的第一个元素的索引，或者如果列表中的所有元素都小于指定的关键字，则为list.size()。请注意，这保证了仅当找到关键字时返回值将是>= 0。
  
  抛出:
  
  ClassCastException - 如果列表包含使用指定比较器不是相互可比较的元素，或者搜索键与列表元素不是使用此比较器相互可比较。
- reverse
  
  public static void reverse(List<?> list)
  
  反转指定列表中元素的顺序。
  此方法运行时间为线性时间。
  API 注意:
  
  此方法会就地更改指定的列表。要获取列表的反向排序视图而不更改它，请使用List.reversed方法。
  
  参数:
  
  list - 要反转其元素的列表。
  
  抛出:
  
  UnsupportedOperationException - 如果指定列表或其列表迭代器不支持set操作。
  
  参见:
  
  List.reversed
- shuffle
  
  public static void shuffle(List<?> list)
  
  使用默认随机源随机排列指定列表。所有排列以大致相等的可能性发生。
  在上述描述中使用“大约”这个词是因为默认随机源只是大约是一个无偏的独立选择位的源。如果它是一个完美的随机选择位的源，那么算法将完全均匀地选择排列。
  
  此实现从后向前遍历列表，从最后一个元素到第二个元素，重复将随机选择的元素交换到“当前位置”。元素是从列表部分中随机选择的，该部分从第一个元素到当前位置，包括当前位置。
  
  实现要求:
  
  此方法运行时间为线性时间。如果指定列表不实现RandomAccess接口并且很大，则此实现将指定列表转储到数组中，然后对其进行洗牌，并将洗牌后的数组转储回列表。这避免了在原地洗牌“顺序访问”列表时产生的二次行为。
  
  参数:
  
  list - 要洗牌的列表。
  
  抛出:
  
  UnsupportedOperationException - 如果指定列表或其列表迭代器不支持set操作。
- shuffle
  
  public static void shuffle(List<?> list, Random rnd)
  
  使用指定的随机源随机排列指定列表。
  此方法等效于shuffle(List, RandomGenerator)，并且存在是为了向后兼容。建议使用shuffle(List, RandomGenerator)方法，因为它不限于扩展Random类的随机生成器。
  
  参数:
  
  list - 要洗牌的列表。
  
  rnd - 用于洗牌列表的随机源。
  
  抛出:
  
  UnsupportedOperationException - 如果指定列表或其列表迭代器不支持set操作。
- shuffle
  
  public static void shuffle(List<?> list, RandomGenerator rnd)
  
  使用指定的随机源随机排列指定列表。假设随机源是公平的，所有排列以相等的可能性发生。
  此实现从后向前遍历列表，从最后一个元素到第二个元素，重复将随机选择的元素交换到“当前位置”。元素是从列表部分中随机选择的，该部分从第一个元素到当前位置，包括当前位置。
  
  实现要求:
  
  该方法在线性时间内运行。如果指定的列表没有实现RandomAccess接口并且很大，该实现会在对其进行洗牌之前将指定的列表转储到数组中，然后将洗牌后的数组转储回列表。这避免了在原地对“顺序访问”列表进行洗牌会导致二次行为。
  
  参数:
  
  list - 要洗牌的列表。
  
  rnd - 用于洗牌列表的随机源。
  
  抛出:
  
  UnsupportedOperationException - 如果指定的列表或其列表迭代器不支持set操作。
  
  自:
  
  21
- swap
  
  public static void swap(List<?> list, int i, int j)
  
  在指定列表中交换指定位置的元素。（如果指定位置相等，则调用此方法不会更改列表。）
  
  参数:
  
  list - 要交换元素的列表。
  
  i - 要交换的一个元素的索引。
  
  j - 要交换的另一个元素的索引。
  
  抛出:
  
  IndexOutOfBoundsException - 如果i或j超出范围（i < 0 || i >= list.size() || j < 0 || j >= list.size()）。
  
  自:
  
  1.4
- fill
  
  public static <T> void fill(List<? super T> list, T obj)
  
  用指定元素替换指定列表的所有元素。
  该方法在线性时间内运行。
  
  类型参数:
  
  T - 列表中对象的类
  
  参数:
  
  list - 要用指定元素填充的列表。
  
  obj - 要用来填充指定列表的元素。
  
  抛出:
  
  UnsupportedOperationException - 如果指定的列表或其列表迭代器不支持set操作。
- copy
  
  public static <T> void copy(List<? super T> dest, List<? extends T> src)
  
  将一个列表中的所有元素复制到另一个列表中。操作完成后，目标列表中每个复制的元素的索引将与源列表中的索引相同。目标列表的大小必须大于或等于源列表的大小。如果大于，目标列表中的剩余元素不受影响。
  该方法在线性时间内运行。
  
  类型参数:
  
  T - 列表中对象的类
  
  参数:
  
  dest - 目标列表。
  
  src - 源列表。
  
  抛出:
  
  IndexOutOfBoundsException - 如果目标列表太小，无法容纳整个源列表。
  
  UnsupportedOperationException - 如果目标列表的列表迭代器不支持set操作。
- min
  
  public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
  
  返回给定集合的最小元素，根据其元素的自然顺序。集合中的所有元素都必须实现Comparable接口。此外，集合中的所有元素必须是可相互比较的（即，对于集合中的任何元素e1和e2，e1.compareTo(e2)不能对ClassCastException抛出异常）。
  该方法遍历整个集合，因此需要的时间与集合的大小成正比。
  类型参数:
  
  T - 集合中对象的类
  
  参数:
  
  coll - 要确定最小元素的集合。
  
  返回:
  
  给定集合的最小元素，根据其元素的自然顺序。
  
  抛出:
  
  ClassCastException - 如果集合包含不是可相互比较的元素（例如，字符串和整数）。
  
  NoSuchElementException - 如果集合为空。
  
  参见:
  
  Comparable
- min
  
  public static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
  
  返回给定集合的最小元素，根据指定比较器引起的顺序。集合中的所有元素必须由指定比较器进行可相互比较（即，对于集合中的任何元素e1和e2，comp.compare(e1, e2)不能对ClassCastException抛出异常）。
  该方法遍历整个集合，因此需要的时间与集合的大小成正比。
  类型参数:
  
  T - 集合中对象的类
  
  参数:
  
  coll - 要确定最小元素的集合。
  
  comp - 用于确定最小元素的比较器。null值表示应使用元素的自然顺序。
  
  返回:
  
  给定集合的最小元素，根据指定比较器。
  
  抛出:
  
  ClassCastException - 如果集合包含不是使用指定比较器进行可相互比较的元素。
  
  NoSuchElementException - 如果集合为空。
  
  参见:
  
  Comparable
- max
  
  public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
  
  返回给定集合的最大元素，根据其元素的自然顺序。集合中的所有元素都必须实现Comparable接口。此外，集合中的所有元素必须是可相互比较的（即，对于集合中的任何元素e1和e2，e1.compareTo(e2)不能对ClassCastException抛出异常）。
  该方法遍历整个集合，因此需要的时间与集合的大小成正比。
  类型参数:
  
  T - 集合中对象的类
  
  参数:
  
  coll - 要确定最大元素的集合。
  
  返回:
  
  给定集合的最大元素，根据其元素的自然顺序。
  
  抛出:
  
  ClassCastException - 如果集合包含不是可相互比较的元素（例如，字符串和整数）。
  
  NoSuchElementException - 如果集合为空。
  
  参见:
  
  Comparable
- max
  
  public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
  
  返回给定集合的最大元素，根据指定比较器引起的顺序。集合中的所有元素必须由指定比较器进行可相互比较（即，对于集合中的任何元素e1和e2，comp.compare(e1, e2)不能对ClassCastException抛出异常）。
  该方法遍历整个集合，因此需要的时间与集合的大小成正比。
  类型参数:
  
  T - 集合中对象的类
  
  参数:
  
  coll - 要确定最大元素的集合。
  
  comp - 用于确定最大元素的比较器。null值表示应使用元素的自然顺序。
  
  返回:
  
  给定集合的最大元素，根据指定比较器。
  
  抛出:
  
  ClassCastException - 如果集合包含不是使用指定比较器进行可相互比较的元素。
  
  NoSuchElementException - 如果集合为空。
  
  参见:
  
  Comparable
- rotate
  
  public static void rotate(List<?> list, int distance)
  旋转指定列表中的元素指定的距离。调用此方法后，索引 i 处的元素将是先前在索引（i-distance） mod list.size()的元素，对于所有 i 的值在 0 和 list.size()-1 之间，包括这两个值。（此方法不会影响列表的大小。）
  例如，假设list包含 [t, a, n, k, s]。调用Collections.rotate(list, 1)（或Collections.rotate(list, -4)）后，list将包含[s, t, a, n, k]。
  
  请注意，此方法可以有用地应用于子列表，以在保留其余元素顺序的同时移动一个或多个元素。例如，以下习语将索引 j 处的元素向前移动到位置 k （必须大于或等于 j ）：
  
  Collections.rotate(list.subList(j, k+1), -1);
  为了具体化这一点，假设list包含[a, b, c, d, e]。要将索引 1 （b）处的元素向前移动两个位置，请执行以下调用：
  Collections.rotate(l.subList(1, 4), -1);
  结果列表是[a, c, d, b, e]。
  要向前移动多个元素，请增加旋转距离的绝对值。要向后移动元素，请使用正移位距离。
  
  如果指定的列表很小或实现了RandomAccess接口，则此实现将第一个元素交换到应该去的位置，然后重复地将被移位的元素交换到应该去的位置，直到被移位的元素被交换到第一个元素。如果需要，该过程将在第二个和后续元素上重复，直到旋转完成。如果指定的列表很大且不实现RandomAccess接口，则此实现将在索引 -distance mod size 周围将列表分为两个子列表视图。然后在每个子列表视图上调用reverse(List)方法，最后在整个列表上调用它。有关这两种算法的更完整描述，请参见Jon Bentley的Programming Pearls第2.3节（Addison-Wesley，1986）。
  参数：
  
  list - 要旋转的列表。
  
  distance - 要旋转列表的距离。对于这个值没有约束；它可以是零、负数或大于list.size()。
  
  抛出：
  
  UnsupportedOperationException - 如果指定的列表或其列表迭代器不支持set操作。
  
  自：
  
  1.4
- replaceAll
  
  public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
  
  用另一个指定值替换列表中所有出现的一个指定值。更正式地说，用newVal替换list中使得(oldVal==null ? e==null : oldVal.equals(e))的每个元素e。（此方法不会影响列表的大小。）
  
  类型参数：
  
  T - 列表中对象的类
  
  参数：
  
  list - 替换操作将发生在其中的列表。
  
  oldVal - 要替换的旧值。
  
  newVal - 用于替换oldVal的新值。
  
  返回：
  
  如果list包含一个或多个元素e使得(oldVal==null ? e==null : oldVal.equals(e))，则返回true。
  
  抛出：
  
  UnsupportedOperationException - 如果指定的列表或其列表迭代器不支持set操作。
  
  自：
  
  1.4
- indexOfSubList
  
  public static int indexOfSubList(List<?> source, List<?> target)
  
  返回指定源列表中指定目标列表的第一次出现的起始位置，如果没有这样的出现则返回-1。更正式地说，返回最低索引 i 使得source.subList(i, i+target.size()).equals(target)，如果没有这样的索引则返回-1。（如果target.size() > source.size()，则返回-1）
  此实现使用“蛮力”技术扫描源列表，依次查找与目标匹配的位置。
  
  参数：
  
  source - 在其中搜索target第一次出现的列表。
  
  target - 作为source子列表搜索的列表。
  
  返回：
  
  指定源列表中指定目标列表的第一次出现的起始位置，如果没有这样的出现则返回-1。
  
  自：
  
  1.4
- lastIndexOfSubList
  
  public static int lastIndexOfSubList(List<?> source, List<?> target)
  
  返回指定源列表中指定目标列表的最后一次出现的起始位置，如果没有这样的出现则返回-1。更正式地说，返回最高索引 i 使得source.subList(i, i+target.size()).equals(target)，如果没有这样的索引则返回-1。（如果target.size() > source.size()，则返回-1）
  此实现使用“蛮力”技术迭代源列表，依次查找与目标匹配的位置。
  
  参数：
  
  source - 在其中搜索target最后一次出现的列表。
  
  target - 作为source子列表搜索的列表。
  
  返回：
  
  指定源列表中指定目标列表的最后一次出现的起始位置，如果没有这样的出现则返回-1。
  
  自：
  
  1.4
- unmodifiableCollection
  
  public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c)
  
  返回指定集合的不可修改视图。返回的集合上的查询操作“读取”到指定的集合，并尝试修改返回的集合，无论是直接还是通过其迭代器，都会导致UnsupportedOperationException。
  返回的集合不会将hashCode和equals操作传递到支持集合，而是依赖于Object的equals和hashCode方法。这是为了在支持集合是集合或列表的情况下保留这些操作的契约。
  
  如果指定的集合是可序列化的，则返回的集合也将是可序列化的。
  
  实现注意：
  
  如果参数已经是不可修改的，则此方法可能会返回其参数。
  
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  c - 要返回不可修改视图的集合。
  
  返回：
  
  指定集合的不可修改视图。
- unmodifiableSequencedCollection
  
  public static <T> SequencedCollection<T> unmodifiableSequencedCollection(SequencedCollection<? extends T> c)
  
  返回指定SequencedCollection的不可修改视图。返回的集合上的查询操作“读取”到指定的集合，并尝试修改返回的集合，无论是直接还是通过其迭代器，都会导致UnsupportedOperationException。
  返回的集合不会将hashCode和equals操作传递到支持集合，而是依赖于Object的equals和hashCode方法。这是为了在支持集合是集合或列表的情况下保留这些操作的契约。
  
  如果指定的集合是可序列化的，则返回的集合也将是可序列化的。
  
  实现注意：
  
  如果参数已经是不可修改的，则此方法可能会返回其参数。
  
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  c - 要返回不可修改视图的集合。
  
  返回：
  
  指定集合的不可修改视图。
  
  自：
  
  21
- unmodifiableSet
  
  public static <T> Set<T> unmodifiableSet(Set<? extends T> s)
  
  返回指定集合的不可修改视图。返回的集合上的查询操作“读取”到指定的集合，并尝试修改返回的集合，无论是直接还是通过其迭代器，都会导致UnsupportedOperationException。
  如果指定的集合是可序列化的，则返回的集合也将是可序列化的。
  
  实现注意：
  
  如果参数已经是不可修改的，则此方法可能会返回其参数。
  
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  s - 要返回不可修改视图的集合。
  
  返回：
  
  指定集合的不可修改视图。
- unmodifiableSequencedSet
  
  public static <T> SequencedSet<T> unmodifiableSequencedSet(SequencedSet<? extends T> s)
  
  返回指定SequencedSet的不可修改视图。返回的集合上的查询操作“读取”到指定的集合，并尝试修改返回的集合，无论是直接还是通过其迭代器，都会导致UnsupportedOperationException。
  如果指定的集合是可序列化的，则返回的集合也将是可序列化的。
  
  实现注意：
  
  如果参数已经是不可修改的，则此方法可能会返回其参数。
  
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  s - 要返回不可修改视图的集合。
  
  返回：
  
  指定排序集合的不可修改视图。
  
  自：
  
  21
- unmodifiableSortedSet
  
  public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)
  
  返回指定排序集合的不可修改视图。返回的排序集合上的查询操作“读取”到指定的排序集合。尝试修改返回的排序集合，无论是直接、通过其迭代器还是通过其subSet、headSet或tailSet视图，都会导致UnsupportedOperationException。
  如果指定的排序集合是可序列化的，则返回的排序集合也将是可序列化的。
  
  实现注意：
  
  如果参数已经是不可修改的，则此方法可能会返回其参数。
  
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  s - 要返回不可修改视图的排序集合。
  
  返回：
  
  指定排序集合的不可修改视图。
- unmodifiableNavigableSet
  
  public static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s)
  
  返回指定可导航集合的不可修改视图。返回的可导航集合上的查询操作会“透传”到指定的可导航集合。尝试修改返回的可导航集合，无论是直接修改，通过其迭代器，还是通过其subSet、headSet或tailSet视图，都会导致UnsupportedOperationException。
  如果指定的可导航集合是可序列化的，则返回的可导航集合也将是可序列化的。
  
  实现注意事项:
  
  如果参数已经是不可修改的，则此方法可能返回其参数。
  
  类型参数:
  
  T - 集合中对象的类
  
  参数:
  
  s - 要返回不可修改视图的可导航集合
  
  返回:
  
  指定可导航集合的不可修改视图
  
  自版本:
  
  1.8
- unmodifiableList
  
  public static <T> List<T> unmodifiableList(List<? extends T> list)
  
  返回指定列表的不可修改视图。返回的列表上的查询操作会“透传”到指定的列表，尝试修改返回的列表，无论是直接修改还是通过其迭代器，都会导致UnsupportedOperationException。
  如果指定的列表是可序列化的，则返回的列表也将是可序列化的。类似地，如果指定的列表是RandomAccess，则返回的列表也将实现RandomAccess。
  
  实现注意事项:
  
  如果参数已经是不可修改的，则此方法可能返回其参数。
  
  类型参数:
  
  T - 列表中对象的类
  
  参数:
  
  list - 要返回不可修改视图的列表
  
  返回:
  
  指定列表的不可修改视图
- unmodifiableMap
  
  public static <K, V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m)
  
  返回指定映射的不可修改视图。返回的映射上的查询操作会“透传”到指定的映射，尝试修改返回的映射，无论是直接修改还是通过其集合视图，都会导致UnsupportedOperationException。
  如果指定的映射是可序列化的，则返回的映射也将是可序列化的。
  
  实现注意事项:
  
  如果参数已经是不可修改的，则此方法可能返回其参数。
  
  类型参数:
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数:
  
  m - 要返回不可修改视图的映射
  
  返回:
  
  指定映射的不可修改视图
- unmodifiableSequencedMap
  
  public static <K, V> SequencedMap<K,V> unmodifiableSequencedMap(SequencedMap<? extends K,? extends V> m)
  
  返回指定SequencedMap的不可修改视图。返回的映射上的查询操作会“透传”到指定的映射，尝试修改返回的映射，无论是直接修改还是通过其集合视图，都会导致UnsupportedOperationException。
  如果指定的映射是可序列化的，则返回的映射也将是可序列化的。
  
  实现注意事项:
  
  如果参数已经是不可修改的，则此方法可能返回其参数。
  
  类型参数:
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数:
  
  m - 要返回不可修改视图的映射
  
  返回:
  
  指定映射的不可修改视图
  
  自版本:
  
  21
- unmodifiableSortedMap
  
  public static <K, V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m)
  
  返回指定排序映射的不可修改视图。返回的排序映射上的查询操作会“透传”到指定的排序映射，尝试修改返回的排序映射，无论是直接修改还是通过其集合视图或其subMap、headMap或tailMap视图，都会导致UnsupportedOperationException。
  如果指定的排序映射是可序列化的，则返回的排序映射也将是可序列化的。
  
  实现注意事项:
  
  如果参数已经是不可修改的，则此方法可能返回其参数。
  
  类型参数:
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数:
  
  m - 要返回不可修改视图的排序映射
  
  返回:
  
  指定排序映射的不可修改视图
- unmodifiableNavigableMap
  
  public static <K, V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K,? extends V> m)
  
  返回指定可导航映射的不可修改视图。返回的可导航映射上的查询操作会“透传”到指定的可导航映射，尝试修改返回的可导航映射，无论是直接修改还是通过其集合视图或其subMap、headMap或tailMap视图，都会导致UnsupportedOperationException。
  如果指定的可导航映射是可序列化的，则返回的可导航映射也将是可序列化的。
  
  实现注意事项:
  
  如果参数已经是不可修改的，则此方法可能返回其参数。
  
  类型参数:
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数:
  
  m - 要返回不可修改视图的可导航映射
  
  返回:
  
  指定可导航映射的不可修改视图
  
  自版本:
  
  1.8
- synchronizedCollection
  
  public static <T> Collection<T> synchronizedCollection(Collection<T> c)
  返回由指定集合支持的同步（线程安全）集合。为了保证串行访问，关键是所有对支持集合的访问都通过返回的集合完成。
  在通过Iterator、Spliterator或Stream遍历时，用户必须手动同步返回的集合：
  
  Collection c = Collections.synchronizedCollection(myCollection); ... synchronized (c) { Iterator i = c.iterator(); // 必须在同步块中 while (i.hasNext()) foo(i.next()); }
  不遵循此建议可能导致非确定性行为。
  返回的集合不会将hashCode和equals操作传递到支持集合，而是依赖于Object的equals和hashCode方法。这是为了在支持集合是集合或列表的情况下保留这些操作的契约。
  
  如果指定的集合是可序列化的，则返回的集合也将是可序列化的。
  类型参数:
  
  T - 集合中对象的类
  
  参数:
  
  c - 要在同步集合中“包装”的集合
  
  返回:
  
  指定集合的同步视图
- synchronizedSet
  
  public static <T> Set<T> synchronizedSet(Set<T> s)
  返回由指定集合支持的同步（线程安全）集合。为了保证串行访问，关键是所有对支持集合的访问都通过返回的集合完成。
  在通过Iterator、Spliterator或Stream遍历时，用户必须手动同步返回的集合：
  
  Set s = Collections.synchronizedSet(new HashSet()); ... synchronized (s) { Iterator i = s.iterator(); // 必须在同步块中 while (i.hasNext()) foo(i.next()); }
  不遵循此建议可能导致非确定性行为。
  如果指定的集合是可序列化的，则返回的集合也将是可序列化的。
  类型参数:
  
  T - 集合中对象的类
  
  参数:
  
  s - 要在同步集合中“包装”的集合
  
  返回:
  
  指定集合的同步视图
- synchronizedSortedSet
  
  public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)
  返回由指定排序集合支持的同步（线程安全）排序集合。为了保证串行访问，关键是所有对支持排序集合的访问都通过返回的排序集合（或其视图）完成。
  在遍历排序集合或其任何subSet、headSet或tailSet视图时，用户必须手动同步返回的排序集合：
  
  SortedSet s = Collections.synchronizedSortedSet(new TreeSet()); ... synchronized (s) { Iterator i = s.iterator(); // 必须在同步块中 while (i.hasNext()) foo(i.next()); }
  或：
  SortedSet s = Collections.synchronizedSortedSet(new TreeSet()); SortedSet s2 = s.headSet(foo); ... synchronized (s) { // 注意：是s，而不是s2！！！ Iterator i = s2.iterator(); // 必须在同步块中 while (i.hasNext()) foo(i.next()); }
  不遵循此建议可能导致非确定性行为。
  如果指定的排序集合是可序列化的，则返回的排序集合也将是可序列化的。
  类型参数:
  
  T - 集合中对象的类
  
  参数:
  
  s - 要在同步排序集合中“包装”的排序集合
  
  返回:
  
  指定排序集合的同步视图
- synchronizedNavigableSet
  
  public static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s)
  返回一个由指定导航集支持的同步（线程安全）导航集。为了保证串行访问，关键是所有对支持导航集的访问都通过返回的导航集（或其视图）完成。
  在遍历时，用户必须手动在返回的导航集上同步，或者通过Iterator、Spliterator或Stream遍历其subSet、headSet或tailSet视图：
  
  NavigableSet s = Collections.synchronizedNavigableSet(new TreeSet()); ... synchronized (s) { Iterator i = s.iterator(); // 必须在同步块中 while (i.hasNext()) foo(i.next()); }
  或者：
  NavigableSet s = Collections.synchronizedNavigableSet(new TreeSet()); NavigableSet s2 = s.headSet(foo, true); ... synchronized (s) { // 注意：是s，不是s2！！！ Iterator i = s2.iterator(); // 必须在同步块中 while (i.hasNext()) foo(i.next()); }
  不遵循此建议可能导致非确定性行为。
  如果指定的导航集是可序列化的，则返回的导航集将是可序列化的。
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  s - 要在同步导航集中“包装”的导航集
  
  返回：
  
  指定导航集的同步视图
  
  自版本：
  
  1.8
- synchronizedList
  
  public static <T> List<T> synchronizedList(List<T> list)
  返回一个由指定列表支持的同步（线程安全）列表。为了保证串行访问，关键是所有对支持列表的访问都通过返回的列表完成。
  在遍历时，用户必须手动在返回的列表上同步，通过Iterator、Spliterator或Stream遍历：
  
  List list = Collections.synchronizedList(new ArrayList()); ... synchronized (list) { Iterator i = list.iterator(); // 必须在同步块中 while (i.hasNext()) foo(i.next()); }
  不遵循此建议可能导致非确定性行为。
  如果指定的列表是可序列化的，则返回的列表将是可序列化的。
  类型参数：
  
  T - 列表中对象的类
  
  参数：
  
  list - 要在同步列表中“包装”的列表
  
  返回：
  
  指定列表的同步视图
- synchronizedMap
  
  public static <K, V> Map<K,V> synchronizedMap(Map<K,V> m)
  返回一个由指定映射支持的同步（线程安全）映射。为了保证串行访问，关键是所有对支持映射的访问都通过返回的映射完成。
  在遍历其任何集合视图时，用户必须手动在返回的映射上同步，通过Iterator、Spliterator或Stream：
  
  Map m = Collections.synchronizedMap(new HashMap()); ... Set s = m.keySet(); // 不需要在同步块中 ... synchronized (m) { // 在m上同步，而不是s！ Iterator i = s.iterator(); // 必须在同步块中 while (i.hasNext()) foo(i.next()); }
  不遵循此建议可能导致非确定性行为。
  如果指定的映射是可序列化的，则返回的映射将是可序列化的。
  类型参数：
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数：
  
  m - 要在同步映射中“包装”的映射
  
  返回：
  
  指定映射的同步视图
- synchronizedSortedMap
  
  public static <K, V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
  返回一个由指定排序映射支持的同步（线程安全）排序映射。为了保证串行访问，关键是所有对支持排序映射的访问都通过返回的排序映射（或其视图）完成。
  在遍历其任何集合视图时，用户必须手动在返回的排序映射上同步，或者通过Iterator、Spliterator或Stream遍历其任何集合视图或其subMap、headMap或tailMap视图：
  
  SortedMap m = Collections.synchronizedSortedMap(new TreeMap()); ... Set s = m.keySet(); // 不需要在同步块中 ... synchronized (m) { // 在m上同步，而不是s！ Iterator i = s.iterator(); // 必须在同步块中 while (i.hasNext()) foo(i.next()); }
  或者：
  SortedMap m = Collections.synchronizedSortedMap(new TreeMap()); SortedMap m2 = m.subMap(foo, bar); ... Set s2 = m2.keySet(); // 不需要在同步块中 ... synchronized (m) { // 在m上同步，而不是m2或s2！ Iterator i = s2.iterator(); // 必须在同步块中 while (i.hasNext()) foo(i.next()); }
  不遵循此建议可能导致非确定性行为。
  如果指定的排序映射是可序列化的，则返回的排序映射将是可序列化的。
  类型参数：
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数：
  
  m - 要在同步排序映射中“包装”的排序映射
  
  返回：
  
  指定排序映射的同步视图
- synchronizedNavigableMap
  
  public static <K, V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m)
  返回一个由指定导航映射支持的同步（线程安全）导航映射。为了保证串行访问，关键是所有对支持导航映射的访问都通过返回的导航映射（或其视图）完成。
  在遍历其任何集合视图时，用户必须手动在返回的导航映射上同步，或者通过Iterator、Spliterator或Stream遍历其任何集合视图或其subMap、headMap或tailMap视图：
  
  NavigableMap m = Collections.synchronizedNavigableMap(new TreeMap()); ... Set s = m.keySet(); // 不需要在同步块中 ... synchronized (m) { // 在m上同步，而不是s！ Iterator i = s.iterator(); // 必须在同步块中 while (i.hasNext()) foo(i.next()); }
  或者：
  NavigableMap m = Collections.synchronizedNavigableMap(new TreeMap()); NavigableMap m2 = m.subMap(foo, true, bar, false); ... Set s2 = m2.keySet(); // 不需要在同步块中 ... synchronized (m) { // 在m上同步，而不是m2或s2！ Iterator i = s2.iterator(); // 必须在同步块中 while (i.hasNext()) foo(i.next()); }
  不遵循此建议可能导致非确定性行为。
  如果指定的导航映射是可序列化的，则返回的导航映射将是可序列化的。
  类型参数：
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数：
  
  m - 要在同步导航映射中“包装”的导航映射
  
  返回：
  
  指定导航映射的同步视图
  
  自版本：
  
  1.8
- checkedCollection
  
  public static <E> Collection<E> checkedCollection(Collection<E> c, Class<E> type)
  返回指定集合的动态类型安全视图。任何尝试插入错误类型的元素都将立即导致ClassCastException。假设在生成动态类型安全视图之前，集合不包含任何错误类型的元素，并且所有后续对集合的访问都通过视图进行，那么可以保证集合不会包含错误类型的元素。
  语言中的泛型机制提供了编译时（静态）类型检查，但是可以通过未经检查的强制转换来破坏此机制。通常情况下，这不是问题，因为编译器会对所有此类未经检查的操作发出警告。然而，有时仅靠静态类型检查是不够的。例如，假设将集合传递给第三方库，并且必须确保库代码不会通过插入错误类型的元素来破坏集合。
  
  动态类型安全视图的另一个用途是调试。假设程序因ClassCastException而失败，表明在参数化集合中插入了错误类型的元素。不幸的是，异常可能在插入错误元素后的任何时间发生，因此通常提供的信息很少或没有关于问题的真正来源。如果问题是可重现的，可以通过临时修改程序以使用动态类型安全视图来快速确定问题的来源。例如，这个声明：
  
  Collection<String> c = new HashSet<>();
  可以临时替换为这个声明：
  Collection<String> c = Collections.checkedCollection( new HashSet<>(), String.class);
  再次运行程序将导致在插入错误类型的元素时失败，清楚地标识问题的来源。问题解决后，可以将修改后的声明恢复为原始状态。
  返回的集合不会将hashCode和equals操作传递到支持集合，而是依赖于Object的equals和hashCode方法。这是为了在支持集合是集或列表的情况下保留这些操作的契约。
  
  如果指定的集合是可序列化的，则返回的集合将是可序列化的。
  
  由于null被视为任何引用类型的值，因此返回的集合允许在支持集合允许时插入null元素。
  类型参数:
  
  E - 集合中对象的类
  
  参数:
  
  c - 要返回动态类型安全视图的集合
  
  type - c 可以容纳的元素类型
  
  返回:
  
  指定集合的动态类型安全视图
  
  自版本:
  
  1.5
- checkedQueue
  
  public static <E> Queue<E> checkedQueue(Queue<E> queue, Class<E> type)
  
  返回指定队列的动态类型安全视图。任何尝试插入错误类型的元素将立即导致 ClassCastException。假设在生成动态类型安全视图之前队列不包含任何错误类型的元素，并且所有后续对队列的访问都通过视图进行，可以保证队列不会包含错误类型的元素。
  关于动态类型安全视图的使用讨论可在 checkedCollection 方法的文档中找到。
  
  如果指定的队列是可序列化的，则返回的队列也将是可序列化的。
  
  由于 null 被视为任何引用类型的值，因此返回的队列允许在支持队列允许的情况下插入 null 元素。
  
  类型参数:
  
  E - 队列中对象的类
  
  参数:
  
  queue - 要返回动态类型安全视图的队列
  
  type - queue 可以容纳的元素类型
  
  返回:
  
  指定队列的动态类型安全视图
  
  自版本:
  
  1.8
- checkedSet
  
  public static <E> Set<E> checkedSet(Set<E> s, Class<E> type)
  
  返回指定集合的动态类型安全视图。任何尝试插入错误类型的元素将立即导致 ClassCastException。假设在生成动态类型安全视图之前集合不包含任何错误类型的元素，并且所有后续对集合的访问都通过视图进行，可以保证集合不会包含错误类型的元素。
  关于动态类型安全视图的使用讨论可在 checkedCollection 方法的文档中找到。
  
  如果指定的集合是可序列化的，则返回的集合也将是可序列化的。
  
  由于 null 被视为任何引用类型的值，因此返回的集合允许在支持集合允许的情况下插入 null 元素。
  
  类型参数:
  
  E - 集合中对象的类
  
  参数:
  
  s - 要返回动态类型安全视图的集合
  
  type - s 可以容纳的元素类型
  
  返回:
  
  指定集合的动态类型安全视图
  
  自版本:
  
  1.5
- checkedSortedSet
  
  public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, Class<E> type)
  
  返回指定排序集的动态类型安全视图。任何尝试插入错误类型的元素将立即导致 ClassCastException。假设在生成动态类型安全视图之前排序集不包含任何错误类型的元素，并且所有后续对排序集的访问都通过视图进行，可以保证排序集不会包含错误类型的元素。
  关于动态类型安全视图的使用讨论可在 checkedCollection 方法的文档中找到。
  
  如果指定的排序集是可序列化的，则返回的排序集也将是可序列化的。
  
  由于 null 被视为任何引用类型的值，因此返回的排序集允许在支持排序集允许的情况下插入 null 元素。
  
  类型参数:
  
  E - 集合中对象的类
  
  参数:
  
  s - 要返回动态类型安全视图的排序集
  
  type - s 可以容纳的元素类型
  
  返回:
  
  指定排序集的动态类型安全视图
  
  自版本:
  
  1.5
- checkedNavigableSet
  
  public static <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s, Class<E> type)
  
  返回指定可导航集的动态类型安全视图。任何尝试插入错误类型的元素将立即导致 ClassCastException。假设在生成动态类型安全视图之前可导航集不包含任何错误类型的元素，并且所有后续对可导航集的访问都通过视图进行，可以保证可导航集不会包含错误类型的元素。
  关于动态类型安全视图的使用讨论可在 checkedCollection 方法的文档中找到。
  
  如果指定的可导航集是可序列化的，则返回的可导航集也将是可序列化的。
  
  由于 null 被视为任何引用类型的值，因此返回的可导航集允许在支持排序集允许的情况下插入 null 元素。
  
  类型参数:
  
  E - 集合中对象的类
  
  参数:
  
  s - 要返回动态类型安全视图的可导航集
  
  type - s 可以容纳的元素类型
  
  返回:
  
  指定可导航集的动态类型安全视图
  
  自版本:
  
  1.8
- checkedList
  
  public static <E> List<E> checkedList(List<E> list, Class<E> type)
  
  返回指定列表的动态类型安全视图。任何尝试插入错误类型的元素将立即导致 ClassCastException。假设在生成动态类型安全视图之前列表不包含任何错误类型的元素，并且所有后续对列表的访问都通过视图进行，可以保证列表不会包含错误类型的元素。
  关于动态类型安全视图的使用讨论可在 checkedCollection 方法的文档中找到。
  
  如果指定的列表是可序列化的，则返回的列表也将是可序列化的。
  
  由于 null 被视为任何引用类型的值，因此返回的列表允许在支持列表允许的情况下插入 null 元素。
  
  类型参数:
  
  E - 列表中对象的类
  
  参数:
  
  list - 要返回动态类型安全视图的列表
  
  type - list 可以容纳的元素类型
  
  返回:
  
  指定列表的动态类型安全视图
  
  自版本:
  
  1.5
- checkedMap
  
  public static <K, V> Map<K,V> checkedMap(Map<K,V> m, Class<K> keyType, Class<V> valueType)
  
  返回指定映射的动态类型安全视图。任何尝试插入键或值类型错误的映射将立即导致 ClassCastException。类似地，任何尝试修改当前与键关联的值都将立即导致 ClassCastException，无论是直接通过映射本身尝试修改，还是通过从映射的 Map.Entry 实例尝试修改。
  假设在生成动态类型安全视图之前映射不包含任何错误类型的键或值，并且所有后续对映射的访问都通过视图（或其集合视图之一）进行，可以保证映射不会包含错误类型的键或值。
  
  关于动态类型安全视图的使用讨论可在 checkedCollection 方法的文档中找到。
  
  如果指定的映射是可序列化的，则返回的映射也将是可序列化的。
  
  由于 null 被视为任何引用类型的值，因此返回的映射允许在支持映射允许的情况下插入 null 键或值。
  
  类型参数:
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数:
  
  m - 要返回动态类型安全视图的映射
  
  keyType - m 可以容纳的键类型
  
  valueType - m 可以容纳的值类型
  
  返回:
  
  指定映射的动态类型安全视图
  
  自版本:
  
  1.5
- checkedSortedMap
  
  public static <K, V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m, Class<K> keyType, Class<V> valueType)
  
  返回指定排序映射的动态类型安全视图。任何尝试插入键或值类型错误的映射将立即导致 ClassCastException。类似地，任何尝试修改当前与键关联的值都将立即导致 ClassCastException，无论是直接通过映射本身尝试修改，还是通过从映射的 Map.Entry 实例尝试修改。
  假设在生成动态类型安全视图之前映射不包含任何错误类型的键或值，并且所有后续对映射的访问都通过视图（或其集合视图之一）进行，可以保证映射不会包含错误类型的键或值。
  
  关于动态类型安全视图的使用讨论可在 checkedCollection 方法的文档中找到。
  
  如果指定的映射是可序列化的，则返回的映射也将是可序列化的。
  
  由于 null 被视为任何引用类型的值，因此返回的映射允许在支持映射允许的情况下插入 null 键或值。
  
  类型参数:
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数:
  
  m - 要返回动态类型安全视图的映射
  
  keyType - m 可以持有的键的类型
  
  valueType - m 可以持有的值的类型
  
  返回:
  
  指定映射的动态类型安全视图
  
  自版本:
  
  1.5
- checkedNavigableMap
  
  public static <K, V> NavigableMap<K,V> checkedNavigableMap(NavigableMap<K,V> m, Class<K> keyType, Class<V> valueType)
  
  返回指定可导航映射的动态类型安全视图。任何尝试插入键或值类型错误的映射将立即导致 ClassCastException。类似地，任何尝试修改当前与键关联的值将立即导致 ClassCastException，无论是直接通过映射本身尝试修改，还是通过从映射的 entry set 视图获取的 Map.Entry 实例尝试修改。
  假设在生成动态类型安全视图之前，映射不包含任何类型错误的键或值，并且所有后续对映射的访问都通过视图（或其集合视图之一）进行，那么可以保证映射不会包含类型错误的键或值。
  
  关于使用动态类型安全视图的讨论可以在 checkedCollection 方法的文档中找到。
  
  如果指定的映射是可序列化的，则返回的映射也将是可序列化的。
  
  由于 null 被视为任何引用类型的值，因此返回的映射允许在支持映射的情况下插入空键或值。
  
  类型参数:
  
  K - 映射键的类型
  
  V - 映射值的类型
  
  参数:
  
  m - 要返回动态类型安全视图的映射
  
  keyType - m 可以持有的键的类型
  
  valueType - m 可以持有的值的类型
  
  返回:
  
  指定映射的动态类型安全视图
  
  自版本:
  
  1.8
- emptyIterator
  
  public static <T> Iterator<T> emptyIterator()
  返回一个没有元素的迭代器。更准确地说，
  
  hasNext 总是返回 false。
  
  next 总是抛出 NoSuchElementException。
  
  remove 总是抛出 IllegalStateException。
  
  允许此方法的实现从多次调用中返回相同的对象，但不是必须的。
  类型参数:
  
  T - 如果有的话，迭代器中元素的类型
  
  返回:
  
  一个空迭代器
  
  自版本:
  
  1.7
- emptyListIterator
  
  public static <T> ListIterator<T> emptyListIterator()
  返回一个没有元素的列表迭代器。更准确地说，
  
  hasNext 和 hasPrevious 总是返回 false。
  
  next 和 previous 总是抛出 NoSuchElementException。
  
  remove 和 set 总是抛出 IllegalStateException。
  
  add 总是抛出 UnsupportedOperationException。
  
  nextIndex 总是返回 0。
  
  previousIndex 总是返回 -1。
  
  允许此方法的实现从多次调用中返回相同的对象，但不是必须的。
  类型参数:
  
  T - 如果有的话，迭代器中元素的类型
  
  返回:
  
  一个空列表迭代器
  
  自版本:
  
  1.7
- emptyEnumeration
  
  public static <T> Enumeration<T> emptyEnumeration()
  返回一个没有元素的枚举。更准确地说，
  
  hasMoreElements 总是返回 false。
  
  nextElement 总是抛出 NoSuchElementException。
  
  允许此方法的实现从多次调用中返回相同的对象，但不是必须的。
  类型参数:
  
  T - 枚举中对象的类
  
  返回:
  
  一个空枚举
  
  自版本:
  
  1.7
- emptySet
  
  public static final <T> Set<T> emptySet()
  返回一个空的集合（不可变）。此集合是可序列化的。与同名字段不同，此方法是参数化的。
  此示例演示了获取空集合的类型安全方式：
  
  Set<String> s = Collections.emptySet();
  实现注意:
  
  此方法的实现不需要为每次调用创建单独的 Set 对象。使用此方法的成本可能与使用同名字段相当。（与此方法不同，该字段不提供类型安全性。）
  
  类型参数:
  
  T - 集合中对象的类
  
  返回:
  
  空集合
  
  自版本:
  
  1.5
  
  参见:
  
  EMPTY_SET
- emptySortedSet
  
  public static <E> SortedSet<E> emptySortedSet()
  返回一个空的排序集（不可变）。此集合是可序列化的。
  此示例演示了获取空排序集的类型安全方式：
  
  SortedSet<String> s = Collections.emptySortedSet();
  实现注意:
  
  此方法的实现不需要为每次调用创建单独的 SortedSet 对象。
  
  类型参数:
  
  E - 如果有的话，集合中元素的类型
  
  返回:
  
  空排序集
  
  自版本:
  
  1.8
- emptyNavigableSet
  
  public static <E> NavigableSet<E> emptyNavigableSet()
  返回一个空的可导航集（不可变）。此集合是可序列化的。
  此示例演示了获取空可导航集的类型安全方式：
  
  NavigableSet<String> s = Collections.emptyNavigableSet();
  实现注意:
  
  此方法的实现不需要为每次调用创建单独的 NavigableSet 对象。
  
  类型参数:
  
  E - 如果有的话，集合中元素的类型
  
  返回:
  
  空可导航集
  
  自版本:
  
  1.8
- emptyList
  
  public static final <T> List<T> emptyList()
  返回一个空列表（不可变）。此列表是可序列化的。
  此示例演示了获取空列表的类型安全方式：
  
  List<String> s = Collections.emptyList();
  实现注意:
  
  此方法的实现不需要为每次调用创建单独的 List 对象。使用此方法的成本可能与使用同名字段相当。（与此方法不同，该字段不提供类型安全性。）
  
  类型参数:
  
  T - 如果有的话，列表中元素的类型
  
  返回:
  
  一个空的不可变列表
  
  自版本:
  
  1.5
  
  参见:
  
  EMPTY_LIST
- emptyMap
  
  public static final <K, V> Map<K,V> emptyMap()
  返回一个空映射（不可变）。此映射是可序列化的。
  此示例演示了获取空映射的类型安全方式：
  
  Map<String, Date> s = Collections.emptyMap();
  实现注意:
  
  此方法的实现不需要为每次调用创建单独的 Map 对象。使用此方法的成本可能与使用同名字段相当。（与此方法不同，该字段不提供类型安全性。）
  
  类型参数:
  
  K - 映射键的类
  
  V - 映射值的类
  
  返回:
  
  一个空映射
  
  自版本:
  
  1.5
  
  参见:
  
  EMPTY_MAP
- emptySortedMap
  
  public static final <K, V> SortedMap<K,V> emptySortedMap()
  
  返回一个包含指定对象的不可变集合。返回的集合是可序列化的。
  
  Implementation Note:
  
  Implementations of this method need not create a separate SortedMap object for each call.
  
  Type Parameters:
  
  K - the class of the map keys
  
  V - the class of the map values
  
  Returns:
  
  an empty sorted map
  
  Since:
  
  1.8
- emptyNavigableMap
  
  public static final <K, V> NavigableMap<K,V> emptyNavigableMap()
  Returns an empty navigable map (immutable). This map is serializable.
  This example illustrates the type-safe way to obtain an empty map:
  
  NavigableMap<String, Date> s = Collections.emptyNavigableMap();
  Implementation Note:
  
  Implementations of this method need not create a separate NavigableMap object for each call.
  
  Type Parameters:
  
  K - the class of the map keys
  
  V - the class of the map values
  
  Returns:
  
  an empty navigable map
  
  Since:
  
  1.8
- singleton
  
  public static <T> Set<T> singleton(T o)
  
  Returns an immutable set containing only the specified object. The returned set is serializable.
  
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  o - 要存储在返回集合中的唯一对象。
  
  返回：
  
  包含指定对象的不可变集合。
- singletonList
  
  public static <T> List<T> singletonList(T o)
  
  返回一个包含指定对象的不可变列表。返回的列表是可序列化的。
  
  类型参数：
  
  T - 列表中对象的类
  
  参数：
  
  o - 要存储在返回列表中的唯一对象。
  
  返回：
  
  包含指定对象的不可变列表。
  
  自：
  
  1.3
- singletonMap
  
  public static <K, V> Map<K,V> singletonMap(K key, V value)
  
  返回一个不可变映射，仅将指定键映射到指定值。返回的映射是可序列化的。
  
  类型参数：
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数：
  
  key - 要存储在返回映射中的唯一键。
  
  value - 返回映射将key映射到的值。
  
  返回：
  
  包含指定键-值映射的不可变映射。
  
  自：
  
  1.3
- nCopies
  
  public static <T> List<T> nCopies(int n, T o)
  
  返回一个包含指定对象的n个副本的不可变列表。新分配的数据对象很小（它包含对数据对象的单个引用）。此方法与List.addAll方法结合使用以扩展列表。返回的列表是可序列化的。
  类型参数：
  
  T - 要复制的对象的类和返回列表中对象的类。
  
  参数：
  
  n - 返回列表中的元素数量。
  
  o - 在返回列表中重复出现的元素。
  
  返回：
  
  由指定对象的n个副本组成的不可变列表。
  
  抛出：
  
  IllegalArgumentException - 如果n < 0
  
  参见：
  
  List.addAll(Collection)
  
  List.addAll(int, Collection)
- reverseOrder
  
  public static <T> Comparator<T> reverseOrder()
  返回一个比较器，对实现Comparable接口的对象集合施加自然顺序的反向排序。（自然顺序是对象自己的compareTo方法施加的顺序。）这使得对实现Comparable接口的对象集合（或数组）进行排序（或维护）的简单习语成为可能，以反向自然顺序排序。例如，假设a是一个字符串数组。然后：
  Arrays.sort(a, Collections.reverseOrder());
  以反向字典顺序（按字母顺序）对数组进行排序。
  返回的比较器是可序列化的。
  API注释：
  
  此方法返回一个适用于以相反顺序对元素进行排序的Comparator。要获取顺序的反向视图，请使用SequencedCollection.reversed方法。或者，要获取顺序的反向视图，请使用SequencedMap.reversed方法。
  
  类型参数：
  
  T - 比较器比较的对象的类
  
  返回：
  
  一个比较器，对实现Comparable接口的对象集合施加自然顺序的反向排序。
  
  参见：
  
  Comparable
- reverseOrder
  
  public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
  
  返回一个施加指定比较器的反向排序的比较器。如果指定的比较器为null，则此方法等效于reverseOrder()（换句话说，它返回一个比较器，对实现Comparable接口的对象集合施加自然顺序的反向排序）。
  返回的比较器是可序列化的（假设指定的比较器也是可序列化的或null）。
  
  API注释：
  
  此方法返回一个适用于以相反顺序对元素进行排序的Comparator。要获取顺序的反向视图，请使用SequencedCollection.reversed方法。或者，要获取顺序的反向视图，请使用SequencedMap.reversed方法。
  
  类型参数：
  
  T - 比较器比较的对象的类
  
  参数：
  
  cmp - 要对其排序进行反向排序的比较器或null
  
  返回：
  
  一个施加指定比较器的反向排序的比较器。
  
  自：
  
  1.5
- enumeration
  
  public static <T> Enumeration<T> enumeration(Collection<T> c)
  
  返回指定集合上的枚举。这提供了与需要枚举作为输入的传统API的互操作性。
  从调用Enumeration.asIterator()返回的迭代器不支持从指定集合中删除元素。这是为了避免意外增加返回的枚举的功能。
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  c - 要返回枚举的集合。
  
  返回：
  
  指定集合上的枚举。
  
  参见：
  
  Enumeration
- list
  
  public static <T> ArrayList<T> list(Enumeration<T> e)
  
  返回一个数组列表，其中包含指定枚举按照枚举返回的顺序返回的元素。此方法提供了返回枚举的传统API和需要集合的新API之间的互操作性。
  类型参数：
  
  T - 枚举返回的对象的类
  
  参数：
  
  e - 提供返回数组列表元素的枚举
  
  返回：
  
  包含指定枚举返回的元素的数组列表。
  
  自：
  
  1.4
  
  参见：
  
  Enumeration
  
  ArrayList
- frequency
  
  public static int frequency(Collection<?> c, Object o)
  
  返回指定集合中等于指定对象的元素数量。更正式地，返回集合中e等于o的元素数量。
  
  参数：
  
  c - 要确定其中o频率的集合
  
  o - 要确定其频率的对象
  
  返回：
  
  集合中等于o的c元素数量
  
  抛出：
  
  NullPointerException - 如果c为null
  
  自：
  
  1.5
- disjoint
  
  public static boolean disjoint(Collection<?> c1, Collection<?> c2)
  
  如果两个指定集合没有共同元素，则返回true。
  如果此方法用于不符合Collection一般契约的集合上，必须小心。实现可以选择迭代其中一个集合并在另一个集合中测试包含性（或执行任何等效计算）。如果任一集合使用非标准相等性测试（如SortedSet的排序与与equals不兼容，或IdentityHashMap的键集），则两个集合必须使用相同的非标准相等性测试，否则此方法的结果是未定义的。
  
  在使用具有对其可能包含的元素有限制的集合时，也必须小心。集合实现允许对它们认为不合格的元素的任何操作抛出异常。为了绝对安全，指定的集合应仅包含对两个集合都是合格元素的元素。
  
  请注意，可以在两个参数中传递相同的集合，此时该方法仅在集合为空时返回true。
  
  参数：
  
  c1 - 一个集合
  
  c2 - 一个集合
  
  返回：
  
  如果两个指定集合没有共同元素，则返回true。
  
  抛出：
  
  NullPointerException - 如果任一集合为null。
  
  NullPointerException - 如果一个集合包含null元素，而null不是另一个集合的合格元素。（可选）
  
  ClassCastException - 如果一个集合包含另一个集合不合格的类型的元素。（可选）
  
  自：
  
  1.5
- addAll
  
  @SafeVarargs public static <T> boolean addAll(Collection<? super T> c, T... elements)
  将所有指定元素添加到指定集合中。要添加的元素可以单独指定，也可以作为数组指定。此便利方法的行为类似于c.addAll(Collections.unmodifiableList(Arrays.asList(elements)))。
  当单独指定元素时，此方法提供了一种向现有集合添加少量元素的便捷方法：
  
  Collections.addAll(flavors, "Peaches 'n Plutonium", "Rocky Racoon");
  类型参数:
  
  T - 要添加的元素的类和集合的类
  
  参数:
  
  c - 要插入elements的集合
  
  elements - 要插入c的元素
  
  返回值:
  
  true 如果集合因调用而更改
  
  抛出:
  
  UnsupportedOperationException - 如果c不支持add操作
  
  NullPointerException - 如果elements包含一个或多个空值且c不允许空元素，或者如果c或elements为null
  
  IllegalArgumentException - 如果elements中某个值的某个属性阻止将其添加到c
  
  自从:
  
  1.5
  
  参见:
  
  Collection.addAll(Collection)
- newSetFromMap
  
  public static <E> Set<E> newSetFromMap(Map<E,Boolean> map)
  返回由指定映射支持的集合。结果集显示与支持映射相同的排序、并发性和性能特征。实质上，此工厂方法提供了与任何映射实现对应的Set实现。不需要在已经具有相应Set实现（如HashMap或TreeMap）上使用此方法。
  通过此方法返回的集合上的每个方法调用都会导致对支持映射或其keySet视图的一次方法调用，只有一个例外。 addAll方法被实现为对支持映射的put调用序列。
  
  在调用此方法时，指定的映射必须为空，并且在此方法返回后不应直接访问。如果映射是空的，直接传递给此方法，并且不保留对映射的引用，则可以确保这些条件，如以下代码片段所示：
  
  Set<Object> weakHashSet = Collections.newSetFromMap( new WeakHashMap<Object, Boolean>());
  类型参数:
  
  E - 映射键的类和返回集合中对象的类
  
  参数:
  
  map - 支持的映射
  
  返回值:
  
  由映射支持的集合
  
  抛出:
  
  IllegalArgumentException - 如果map不为空
  
  自从:
  
  1.6
- newSequencedSetFromMap
  
  public static <E> SequencedSet<E> newSequencedSetFromMap(SequencedMap<E,Boolean> map)
  
  返回由指定映射支持的序列化集合。结果集显示与支持映射相同的排序、并发性和性能特征。实质上，此工厂方法提供了与任何SequencedMap实现对应的SequencedSet实现。
  通过此方法返回的集合上的每个方法调用都会导致对支持映射或其keySet视图的一次方法调用，只有一个例外。 addAll方法被实现为对支持映射的put调用序列。
  
  在调用此方法时，指定的映射必须为空，并且在此方法返回后不应直接访问。这些条件可以通过创建空映射、直接传递给此方法并且不保留对映射的引用来确保，如下面的代码片段所示：
  API 注意:
  
  以下示例代码从LinkedHashMap创建SequencedSet。这与LinkedHashSet不同，因为映射的removeEldestEntry被覆盖以提供驱逐策略，而LinkedHashSet不可能实现这一点。
  
  SequencedSet<String> set = Collections.newSequencedSetFromMap( new LinkedHashMap<String, Boolean>() { protected boolean removeEldestEntry(Map.Entry<String, Boolean> e) { return this.size() > 5; } });
  
  类型参数:
  
  E - 映射键的类和返回集合中对象的类
  
  参数:
  
  map - 支持的映射
  
  返回值:
  
  由映射支持的集合
  
  抛出:
  
  IllegalArgumentException - 如果map不为空
  
  自从:
  
  21
- asLifoQueue
  
  public static <T> Queue<T> asLifoQueue(Deque<T> deque)
  
  返回将Deque视为后进先出（Lifo）Queue的视图。方法add映射到push，remove映射到pop等。当您想要使用需要Queue的方法但需要Lifo排序时，此视图可能很有用。
  通过此方法返回的队列上的每个方法调用都会导致对支持的双端队列的一次方法调用，只有一个例外。 addAll方法被实现为对支持的双端队列的addFirst调用序列。
  
  API 注意:
  
  此方法提供了一个视图，颠倒了某些操作的意义，但没有颠倒遇到的顺序。要获取一个反向排序的视图，请使用Deque.reversed方法。
  
  类型参数:
  
  T - 双端队列中对象的类
  
  参数:
  
  deque - 双端队列
  
  返回值:
  
  队列
  
  自从:
  
  1.6

Class Collections

Field Summary

Method Summary

Methods declared in class java.lang.Object

Field Details

EMPTY_SET

EMPTY_LIST

EMPTY_MAP

Method Details

sort

sort

binarySearch

binarySearch

reverse

shuffle

shuffle

shuffle

swap

fill

copy

min

min

max

max

rotate

replaceAll

indexOfSubList

lastIndexOfSubList

unmodifiableCollection

unmodifiableSequencedCollection

unmodifiableSet

unmodifiableSequencedSet

unmodifiableSortedSet

unmodifiableNavigableSet

unmodifiableList

unmodifiableMap

unmodifiableSequencedMap

unmodifiableSortedMap

unmodifiableNavigableMap

synchronizedCollection

synchronizedSet

synchronizedSortedSet

synchronizedNavigableSet

synchronizedList

synchronizedMap

synchronizedSortedMap

synchronizedNavigableMap

checkedCollection

checkedQueue

checkedSet

checkedSortedSet

checkedNavigableSet

checkedList

checkedMap

checkedSortedMap

checkedNavigableMap

emptyIterator

emptyListIterator

emptyEnumeration

emptySet

emptySortedSet

emptyNavigableSet

emptyList

emptyMap

emptySortedMap

emptyNavigableMap

singleton

singletonList

singletonMap

nCopies

reverseOrder

reverseOrder

enumeration

list

frequency

disjoint

addAll

newSetFromMap

newSequencedSetFromMap

asLifoQueue