java.lang.Object

java.util.Collections

public class Collections extends Object

此类仅包含对集合进行操作或返回集合的静态方法。它包含对集合、“包装器”进行操作的多态算法，“包装器”返回由指定集合支持的新集合，以及其他一些零碎的东西。

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

此类中包含的多态算法的文档通常包括对执行.此类描述应视为实施说明, 而不是部分规格.只要遵守规范本身，实施者就可以随意替换其他算法。（例如，sort 使用的算法不一定是合并排序，但它必须是稳定的.)

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

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

自从：

1.2

参见：

字段摘要

字段

修饰符和类型

Field

描述

static final List

EMPTY_LIST

空列表（不可变）。

static final Map

EMPTY_MAP

空map（不可变）。

static final Set

EMPTY_SET

空集（不可变）。
方法总结

修饰符和类型

方法

描述

static <T> boolean

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

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

static <T> Queue<T>

asLifoQueue(Deque<T> deque)

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

static <T> int

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

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

static <T> int

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

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

static <E> Collection<E>

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

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

static <E> List<E>

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

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

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

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

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

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

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

返回指定可navigable map的动态类型安全视图。

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

返回一个空map（不可变）。

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

emptyNavigableMap()

返回一个空的可navigable map（不可变）。

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> Set<E>

newSetFromMap(Map<E,Boolean> map)

返回由指定map支持的集合。

static <T> boolean

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

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

static void

reverse(List<?> list)

反转指定列表中元素的顺序。

static <T> Comparator<T>

reverseOrder()

返回一个比较器，该比较器对实现 Comparable 接口的对象集合施加 natural ordering 的反转。

static <T> Comparator<T>

reverseOrder(Comparator<T> cmp)

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

static void

rotate(List<?> list, int distance)

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

static void

shuffle(List<?> list)

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

static void

shuffle(List<?> list, Random rnd)

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

static <T> Set<T>

singleton(T o)

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

static <T> List<T>

singletonList(T o)

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

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

singletonMap(K key, V value)

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

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

sort(List<T> list)

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

static <T> void

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

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

static void

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

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

static <T> Collection<T>

synchronizedCollection(Collection<T> c)

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

static <T> List<T>

synchronizedList(List<T> list)

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

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

synchronizedMap(Map<K,V> m)

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

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

synchronizedNavigableMap(NavigableMap<K,V> m)

返回由指定的可navigable map支持的同步（线程安全）可navigable map。

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)

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

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

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

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

static <T> NavigableSet<T>

unmodifiableNavigableSet(NavigableSet<T> s)

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

static <T> Set<T>

unmodifiableSet(Set<? extends T> s)

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

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

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

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

static <T> SortedSet<T>

unmodifiableSortedSet(SortedSet<T> s)

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

在类 java.lang.Object 中声明的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

字段详细信息
- EMPTY_SET
  
  public static final Set EMPTY_SET
  
  空集（不可变）。这个集合是可序列化的。
  参见：
  
  emptySet()
- EMPTY_LIST
  
  public static final List EMPTY_LIST
  
  空列表（不可变）。这个列表是可序列化的。
  参见：
  
  emptyList()
- EMPTY_MAP
  
  public static final Map EMPTY_MAP
  
  空map（不可变）。该map是可序列化的。
  自从：
  
  1.3
  
  参见：
  
  emptyMap()
方法详情
- sort
  
  public static <T extends Comparable <? super T>> void sort(List <T> list)
  
  根据其元素的自然排序将指定列表按升序排序。列表中的所有元素都必须实现 Comparable 接口。此外，列表中的所有元素都必须是相互比较（也就是说，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)
  
  根据指定比较器产生的顺序对指定列表进行排序。列表中的所有元素必须是相互比较使用指定的比较器（即，c.compare(e1, e2) 不得为列表中的任何元素 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 - 要搜索的键。
  
  返回：
  
  搜索关键字的索引，如果它包含在列表中；否则，(-(insertion point) - 1)。这插入点被定义为将键插入列表的点：大于键的第一个元素的索引，或者 list.size() 如果列表中的所有元素都小于指定的键。请注意，当且仅当找到密钥时，这保证返回值 >= 0。
  
  抛出：
  
  ClassCastException - 如果列表中包含的元素不是相互比较（例如，字符串和整数），或者搜索关键字与列表的元素不可相互比较。
- binarySearch
  
  public static <T> int binarySearch(List <? extends T> list, T key, Comparator <? super T> c)
  
  使用二进制搜索算法在指定列表中搜索指定对象。在进行此调用之前，必须根据指定的比较器（如通过 sort(List, Comparator) 方法）将列表排序为升序。如果未排序，则结果未定义。如果列表包含多个等于指定对象的元素，则无法保证找到哪一个。
  此方法在“随机访问”列表（提供近乎恒定时间的位置访问）的 log(n) 时间内运行。如果指定的列表未实现 RandomAccess 接口并且很大，则此方法将执行基于迭代器的二进制搜索，执行 O(n) 链接遍历和 O(log n) 元素比较。
  
  类型参数：
  
  T - 列表中对象的类
  
  参数：
  
  list - 要搜索的列表。
  
  key - 要搜索的键。
  
  c - 列表排序的比较器。 null 值表示应使用元素的自然排序。
  
  返回：
  
  搜索关键字的索引，如果它包含在列表中；否则，(-(insertion point) - 1)。这插入点被定义为将键插入列表的点：大于键的第一个元素的索引，或者 list.size() 如果列表中的所有元素都小于指定的键。请注意，当且仅当找到密钥时，这保证返回值 >= 0。
  
  抛出：
  
  ClassCastException - 如果列表中包含的元素不是相互比较使用指定的比较器，或者搜索关键字与使用此比较器的列表的元素不可相互比较。
- reverse
  
  public static void reverse(List <?> list)
  
  反转指定列表中元素的顺序。
  该方法以线性时间运行。
  
  参数：
  
  list - 其元素要反转的列表。
  
  抛出：
  
  UnsupportedOperationException - 如果指定列表或其列表迭代器不支持 set 操作。
- shuffle
  
  public static void shuffle(List <?> list)
  
  使用默认的随机源随机排列指定的列表。所有排列以近似相等的可能性发生。
  在前面的描述中使用了对冲“大约”，因为随机性的默认源只是大约独立选择的位的无偏源。如果它是随机选择位的完美来源，那么该算法将选择具有完美均匀性的排列。
  
  此实现向后遍历列表，从最后一个元素到第二个元素，重复将随机选择的元素交换到“当前位置”。元素是从列表中从第一个元素到当前位置（含）的部分随机选择的。
  
  该方法以线性时间运行。如果指定的列表没有实现 RandomAccess 接口并且很大，则此实现会在对它进行混洗之前将指定的列表转储到一个数组中，并将混洗后的数组转储回列表中。这避免了因在适当位置改组“顺序访问”列表而导致的二次行为。
  
  参数：
  
  list - 要洗牌的列表。
  
  抛出：
  
  UnsupportedOperationException - 如果指定列表或其列表迭代器不支持 set 操作。
- shuffle
  
  public static void shuffle(List <?> list, Random rnd)
  
  使用指定的随机源随机排列指定的列表。假设随机源是公平的，所有排列都以相同的可能性发生。
  此实现向后遍历列表，从最后一个元素到第二个元素，重复将随机选择的元素交换到“当前位置”。元素是从列表中从第一个元素到当前位置（含）的部分随机选择的。
  
  该方法以线性时间运行。如果指定的列表没有实现 RandomAccess 接口并且很大，则此实现会在对它进行混洗之前将指定的列表转储到一个数组中，并将混洗后的数组转储回列表中。这避免了因在适当位置改组“顺序访问”列表而导致的二次行为。
  
  参数：
  
  list - 要洗牌的列表。
  
  rnd - 用于随机播放列表的随机源。
  
  抛出：
  
  UnsupportedOperationException - 如果指定列表或其列表迭代器不支持 set 操作。
- 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.compareTo(e2) 不得为集合中的任何元素 e1 和 e2 抛出 ClassCastException）。
  此方法遍历整个集合，因此需要的时间与集合的大小成正比。
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  coll - 要确定其最小元素的集合。
  
  返回：
  
  给定集合的最小元素，根据自然排序它的元素。
  
  抛出：
  
  ClassCastException - 如果集合中包含的元素不是相互比较（例如，字符串和整数）。
  
  NoSuchElementException - 如果集合为空。
  
  参见：
  
  Comparable
- min
  
  public static <T> T min(Collection <? extends T> coll, Comparator <? super T> comp)
  
  根据指定比较器引发的顺序，返回给定集合的最小元素。集合中的所有元素必须是相互比较由指定的比较器（即，comp.compare(e1, e2) 不得为集合中的任何元素 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.compareTo(e2) 不得为集合中的任何元素 e1 和 e2 抛出 ClassCastException）。
  此方法遍历整个集合，因此需要的时间与集合的大小成正比。
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  coll - 要确定其最大元素的集合。
  
  返回：
  
  给定集合的最大元素，根据自然排序它的元素。
  
  抛出：
  
  ClassCastException - 如果集合中包含的元素不是相互比较（例如，字符串和整数）。
  
  NoSuchElementException - 如果集合为空。
  
  参见：
  
  Comparable
- max
  
  public static <T> T max(Collection <? extends T> coll, Comparator <? super T> comp)
  
  根据指定比较器引起的顺序，返回给定集合的最大元素。集合中的所有元素必须是相互比较由指定的比较器（即，comp.compare(e1, e2) 不得为集合中的任何元素 e1 和 e2 抛出 ClassCastException）。
  此方法遍历整个集合，因此需要的时间与集合的大小成正比。
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  coll - 要确定其最大元素的集合。
  
  comp - 用于确定最大元素的比较器。 null 值表示元素'自然排序应该使用。
  
  返回：
  
  根据指定的比较器，给定集合的最大元素。
  
  抛出：
  
  ClassCastException - 如果集合中包含的元素不是相互比较使用指定的比较器。
  
  NoSuchElementException - 如果集合为空。
  
  参见：
  
  Comparable
- rotate
  
  public static void rotate(List <?> list, int distance)
  按指定距离旋转指定列表中的元素。调用此方法后，对于 0 和 list.size()-1 之间的所有 i 值，索引 i 处的元素将是之前索引 (i - distance) mod list.size() 处的元素，包括在内。（此方法对列表的大小没有影响。）
  例如，假设 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 的第 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 中的每个元素 e 使得 (oldVal==null ? e==null : oldVal.equals(e)) 。（此方法对列表的大小没有影响。）
  
  类型参数：
  
  T - 列表中对象的类
  
  参数：
  
  list - 发生替换的列表。
  
  oldVal - 要替换的旧值。
  
  newVal - 要替换 oldVal 的新值。
  
  返回：
  
  true 如果 list 包含一个或多个元素 e 这样 (oldVal==null ? e==null : oldVal.equals(e)) 。
  
  抛出：
  
  UnsupportedOperationException - 如果指定列表或其列表迭代器不支持 set 操作。
  
  自从：
  
  1.4
- indexOfSubList
  
  public static int indexOfSubList(List <?> source, List <?> target)
  
  返回指定源列表中指定目标列表第一次出现的起始位置，如果不存在则返回 -1。更正式地说，返回最低索引 i 这样 source.subList(i, i+target.size()).equals(target) ，或 -1 如果没有这样的索引。（返回 -1 如果 target.size() > source.size() ）
  此实现使用扫描源列表的“蛮力”技术，依次在每个位置寻找与目标的匹配项。
  
  参数：
  
  source - 要在其中搜索第一次出现的 target 的列表。
  
  target - 作为 source 的子列表搜索的列表。
  
  返回：
  
  指定源列表中指定目标列表第一次出现的起始位置，如果没有出现则为 -1。
  
  自从：
  
  1.4
- lastIndexOfSubList
  
  public static int lastIndexOfSubList(List <?> source, List <?> target)
  
  返回指定源列表中指定目标列表最后一次出现的起始位置，如果不存在则返回 -1。更正式地说，返回最高索引 i 这样 source.subList(i, i+target.size()).equals(target) ，或者 -1 如果没有这样的索引。（返回 -1 如果 target.size() > source.size() ）
  此实现使用迭代源列表的“蛮力”技术，依次在每个位置查找与目标的匹配项。
  
  参数：
  
  source - 要在其中搜索最后一次出现的 target 的列表。
  
  target - 作为 source 的子列表搜索的列表。
  
  返回：
  
  指定源列表中指定目标列表最后一次出现的起始位置，如果没有这样的出现，则为 -1。
  
  自从：
  
  1.4
- unmodifiableCollection
  
  public static <T> Collection <T> unmodifiableCollection(Collection <? extends T> c)
  
  返回指定集合的不可修改的视图。对返回集合的查询操作“通读”到指定的集合，并尝试修改返回的集合，无论是直接还是通过其迭代器，都会导致 UnsupportedOperationException 。
  返回的集合确实not将 hashCode 和 equals 操作传递给后备集合，但依赖于 Object 的 equals 和 hashCode 方法。在后备集合是集合或列表的情况下，这是保留这些操作的契约所必需的。
  
  如果指定的集合是可序列化的，则返回的集合将是可序列化的。
  
  实现注意事项：
  
  如果参数已经不可修改，则此方法可能会返回其参数。
  
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  c - 要为其返回不可修改视图的集合。
  
  返回：
  
  指定集合的不可修改视图。
- unmodifiableSet
  
  public static <T> Set <T> unmodifiableSet(Set <? extends T> s)
  
  返回指定集合的不可修改的视图。对返回集的查询操作“通读”到指定集，并尝试修改返回集，无论是直接还是通过其迭代器，都会导致 UnsupportedOperationException 。
  如果指定的集是可序列化的，则返回的集将是可序列化的。
  
  实现注意事项：
  
  如果参数已经不可修改，则此方法可能会返回其参数。
  
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  s - 要为其返回不可修改视图的集合。
  
  返回：
  
  指定集合的不可修改视图。
- 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 。
  
  实现注意事项：
  
  如果参数已经不可修改，则此方法可能会返回其参数。
  
  类型参数：
  
  T - 列表中对象的类
  
  参数：
  
  list - 要为其返回不可修改视图的列表。
  
  返回：
  
  指定列表的不可修改视图。
- unmodifiableMap
  
  public static <K, V> Map <K,V> unmodifiableMap(Map <? extends K,? extends V> m)
  
  返回指定map的不可修改的视图。返回map上的查询操作“通读”到指定的map，并尝试修改返回的map，无论是直接还是通过其集合视图，都会导致 UnsupportedOperationException 。
  如果指定的map是可序列化的，则返回的map将是可序列化的。
  
  实现注意事项：
  
  如果参数已经不可修改，则此方法可能会返回其参数。
  
  类型参数：
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数：
  
  m - 要为其返回不可修改视图的map。
  
  返回：
  
  指定map的不可修改视图。
- 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)
  
  返回指定导航map的不可修改的视图。对返回的可导航map的查询操作“通读”到指定的可导航map。尝试修改返回的可导航map，无论是直接修改，还是通过其集合视图，或通过其 subMap、headMap 或 tailMap 视图，都会导致 UnsupportedOperationException。
  如果指定的可navigable map是可序列化的，则返回的可navigable map将是可序列化的。
  
  实现注意事项：
  
  如果参数已经不可修改，则此方法可能会返回其参数。
  
  类型参数：
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数：
  
  m - 要为其返回不可修改视图的可导航map
  
  返回：
  
  指定navigable map的不可修改视图
  
  自从：
  
  1.8
- synchronizedCollection
  
  public static <T> Collection <T> synchronizedCollection(Collection <T> c)
  返回由指定集合支持的同步（线程安全）集合。为了保证串行访问，all 对后备集合的访问是通过返回的集合完成的，这一点至关重要。
  当通过 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()); }
  不遵循此建议可能会导致不确定的行为。
  返回的集合确实not将 hashCode 和 equals 操作传递给后备集合，但依赖于 Object 的 equals 和 hashCode 方法。在后备集合是集合或列表的情况下，这是保留这些操作的契约所必需的。
  
  如果指定的集合是可序列化的，则返回的集合将是可序列化的。
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  c - 要“包装”在同步集合中的集合。
  
  返回：
  
  指定集合的同步视图。
- synchronizedSet
  
  public static <T> Set <T> synchronizedSet(Set <T> s)
  返回由指定集支持的同步（线程安全）集。为了保证串行访问，all 对后备集的访问是通过返回集完成的，这一点至关重要。
  当通过 Iterator 、 Spliterator 或 Stream 遍历它时，用户必须手动同步返回的集合：
  
  Set s = Collections.synchronizedSet(new HashSet()); ... synchronized (s) { Iterator i = s.iterator(); // Must be in the synchronized block while (i.hasNext()) foo(i.next()); }
  不遵循此建议可能会导致不确定的行为。
  如果指定的集是可序列化的，则返回的集将是可序列化的。
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  s - 要“包装”在同步集中的集。
  
  返回：
  
  指定集合的同步视图。
- synchronizedSortedSet
  
  public static <T> SortedSet <T> synchronizedSortedSet(SortedSet <T> s)
  返回由指定排序集支持的同步（线程安全）排序集。为了保证串行访问，all 对后备排序集的访问是通过返回的排序集（或其视图）完成的，这一点至关重要。
  当通过Iterator 、Spliterator 或Stream 遍历它或它的任何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()); }
  未能遵循此建议可能会导致不确定的行为。
  如果指定的排序集是可序列化的，则返回的排序集将是可序列化的。
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  s - 要“包装”在同步排序集中的排序集。
  
  返回：
  
  指定排序集的同步视图。
- synchronizedNavigableSet
  
  public static <T> NavigableSet <T> synchronizedNavigableSet(NavigableSet <T> s)
  返回由指定的可导航集支持的同步（线程安全）可导航集。为了保证串行访问，all 对后备可导航集的访问是通过返回的可导航集（或其视图）完成的，这一点至关重要。
  用户必须在遍历它时手动同步返回的可导航集，或者它的任何 subSet 、 headSet 或 tailSet 视图，通过 Iterator 、 Spliterator 或 Stream ：
  
  NavigableSet s = Collections.synchronizedNavigableSet(new TreeSet()); ... synchronized (s) { Iterator i = s.iterator(); // Must be in the synchronized block while (i.hasNext()) foo(i.next()); }
  或：
  NavigableSet s = Collections.synchronizedNavigableSet(new TreeSet()); NavigableSet s2 = s.headSet(foo, true); ... synchronized (s) { // Note: s, not s2!!! Iterator i = s2.iterator(); // Must be in the synchronized block while (i.hasNext()) foo(i.next()); }
  未能遵循此建议可能会导致不确定的行为。
  如果指定的可导航集是可序列化的，则返回的可导航集将是可序列化的。
  类型参数：
  
  T - 集合中对象的类
  
  参数：
  
  s - 在同步可导航集中“包装”的可导航集
  
  返回：
  
  指定可导航集的同步视图
  
  自从：
  
  1.8
- synchronizedList
  
  public static <T> List <T> synchronizedList(List <T> list)
  返回由指定列表支持的同步（线程安全）列表。为了保证串行访问，all 对支持列表的访问是通过返回的列表完成的，这一点至关重要。
  当通过 Iterator 、 Spliterator 或 Stream 遍历它时，用户必须在返回的列表上手动同步：
  
  List list = Collections.synchronizedList(new ArrayList()); ... synchronized (list) { Iterator i = list.iterator(); // Must be in synchronized block while (i.hasNext()) foo(i.next()); }
  不遵循此建议可能会导致不确定的行为。
  如果指定的列表是可序列化的，则返回的列表将是可序列化的。
  类型参数：
  
  T - 列表中对象的类
  
  参数：
  
  list - 要在同步列表中“包装”的列表。
  
  返回：
  
  指定列表的同步视图。
- synchronizedMap
  
  public static <K, V> Map <K,V> synchronizedMap(Map <K,V> m)
  返回由指定map支持的同步（线程安全）映射。为了保证串行访问，all 对支持map的访问是通过返回的映射完成的，这一点至关重要。
  当通过 Iterator 、 Spliterator 或 Stream 遍历其任何集合视图时，用户必须在返回的map上手动同步：
  
  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()); }
  不遵循此建议可能会导致不确定的行为。
  如果指定的map是可序列化的，则返回的map将是可序列化的。
  类型参数：
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数：
  
  m - 要在同步map中“包装”的map。
  
  返回：
  
  指定map的同步视图。
- synchronizedSortedMap
  
  public static <K, V> SortedMap <K,V> synchronizedSortedMap(SortedMap <K,V> m)
  返回由指定排序映射支持的同步（线程安全）排序映射。为了保证串行访问，all 对后备排序映射的访问是通过返回的排序映射（或其视图）完成的，这一点至关重要。
  当用户通过 Iterator 、 Spliterator 或 Stream 遍历其任何集合视图或其任何 subMap 、 headMap 或 tailMap 视图的集合视图时，用户必须在返回的排序map上手动同步：
  
  SortedMap m = Collections.synchronizedSortedMap(new TreeMap()); ... Set s = m.keySet(); // Needn't be in synchronized block ... synchronized (m) { // Synchronizing on m, not s! Iterator i = s.iterator(); // Must be in synchronized block while (i.hasNext()) foo(i.next()); }
  或：
  SortedMap m = Collections.synchronizedSortedMap(new TreeMap()); SortedMap m2 = m.subMap(foo, bar); ... Set s2 = m2.keySet(); // Needn't be in synchronized block ... synchronized (m) { // Synchronizing on m, not m2 or s2! Iterator i = s2.iterator(); // Must be in synchronized block while (i.hasNext()) foo(i.next()); }
  未能遵循此建议可能会导致不确定的行为。
  如果指定的排序映射是可序列化的，则返回的排序映射将是可序列化的。
  类型参数：
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数：
  
  m - 要“包装”在同步排序map中的排序map。
  
  返回：
  
  指定排序map的同步视图。
- synchronizedNavigableMap
  
  public static <K, V> NavigableMap <K,V> synchronizedNavigableMap(NavigableMap <K,V> m)
  返回由指定的可导航map支持的同步（线程安全）可导航map。为了保证串行访问，all 对后备导航map的访问是通过返回的导航map（或其视图）完成的，这一点至关重要。
  当用户通过 Iterator 、 Spliterator 或 Stream 遍历其任何集合视图或其任何 subMap 、 headMap 或 tailMap 视图的集合视图时，用户必须在返回的可导航map上手动同步：
  
  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()); }
  未能遵循此建议可能会导致不确定的行为。
  如果指定的可navigable map是可序列化的，则返回的可navigable map将是可序列化的。
  类型参数：
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数：
  
  m - 要“包装”在同步可导航map中的可导航map
  
  返回：
  
  指定navigable map的同步视图。
  
  自从：
  
  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);
  再次运行该程序将导致它在将错误类型的元素插入到集合中时失败，从而清楚地确定问题的根源。一旦问题得到解决，修改后的声明可能会恢复到原来的状态。
  返回的集合确实not将 hashCode 和 equals 操作传递给后备集合，但依赖于 Object 的 equals 和 hashCode 方法。在后备集合是集合或列表的情况下，这是保留这些操作的契约所必需的。
  
  如果指定的集合是可序列化的，则返回的集合将是可序列化的。
  
  由于 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 被认为是任何引用类型的值，因此只要后备集这样做，返回的集合就允许插入空元素。
  
  类型参数：
  
  E - 集合中对象的类
  
  参数：
  
  s - 要为其返回动态类型安全视图的集合
  
  type - s 允许持有的元素类型
  
  返回：
  
  指定集合的动态类型安全视图
  
  自从：
  
  1.5
- checkedSortedSet
  
  public static <E> SortedSet <E> checkedSortedSet(SortedSet <E> s, Class <E> type)
  
  返回指定排序集的动态类型安全视图。任何插入错误类型元素的尝试都会立即导致 ClassCastException 。假设在生成动态类型安全视图之前，排序集不包含类型不正确的元素，并且所有后续对排序集的访问都通过视图进行，它是保证排序集不能包含类型不正确的元素。
  可以在 checkedCollection 方法的文档中找到有关使用动态类型安全视图的讨论。
  
  如果指定的排序集是可序列化的，则返回的排序集将是可序列化的。
  
  由于 null 被认为是任何引用类型的值，因此返回的排序集允许在后备排序集执行时插入空元素。
  
  类型参数：
  
  E - 集合中对象的类
  
  参数：
  
  s - 要为其返回动态类型安全视图的排序集
  
  type - s 允许持有的元素类型
  
  返回：
  
  指定排序集的动态类型安全视图
  
  自从：
  
  1.5
- checkedNavigableSet
  
  public static <E> NavigableSet <E> checkedNavigableSet(NavigableSet <E> s, Class <E> type)
  
  返回指定可导航集的动态类型安全视图。任何插入错误类型元素的尝试都会立即导致 ClassCastException 。假设在生成动态类型安全视图之前，可导航集不包含类型不正确的元素，并且对可导航集的所有后续访问都通过该视图进行，那么导航集不能包含类型不正确的元素是guaranteed。
  可以在 checkedCollection 方法的文档中找到有关使用动态类型安全视图的讨论。
  
  如果指定的可导航集是可序列化的，则返回的可导航集将是可序列化的。
  
  由于 null 被认为是任何引用类型的值，因此返回的可导航集允许在支持排序集时插入空元素。
  
  类型参数：
  
  E - 集合中对象的类
  
  参数：
  
  s - 将为其返回动态类型安全视图的可导航集
  
  type - s 允许持有的元素类型
  
  返回：
  
  指定可导航集的动态类型安全视图
  
  自从：
  
  1.8
- checkedList
  
  public static <E> List <E> checkedList(List <E> list, Class <E> type)
  
  返回指定列表的动态类型安全视图。任何插入错误类型元素的尝试都会立即导致 ClassCastException 。假设在生成动态类型安全视图之前列表不包含类型不正确的元素，并且所有后续对列表的访问都是通过视图进行的，它是保证该列表不能包含类型不正确的元素。
  可以在 checkedCollection 方法的文档中找到有关使用动态类型安全视图的讨论。
  
  如果指定的列表是可序列化的，则返回的列表将是可序列化的。
  
  由于 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)
  
  返回指定map的动态类型安全视图。任何尝试插入其键或值具有错误类型的映射都将导致立即 ClassCastException 。类似地，任何修改当前与键关联的值的尝试都将导致立即 ClassCastException ，无论是直接通过映射本身尝试修改，还是通过从映射的 entry set 视图获得的 Map.Entry 实例进行修改。
  假设在生成动态类型安全视图之前映射不包含错误键入的键或值，并且所有后续对映射的访问都是通过视图（或其集合视图之一）进行的，它是保证映射不能包含错误键入的键或值。
  
  可以在 checkedCollection 方法的文档中找到有关使用动态类型安全视图的讨论。
  
  如果指定的map是可序列化的，则返回的map将是可序列化的。
  
  由于 null 被认为是任何引用类型的值，因此无论何时支持map，返回的映射都允许插入空键或值。
  
  类型参数：
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数：
  
  m - 要为其返回动态类型安全视图的映射
  
  keyType - 允许 m 持有的密钥类型
  
  valueType - m 允许持有的值的类型
  
  返回：
  
  指定map的动态类型安全视图
  
  自从：
  
  1.5
- checkedSortedMap
  
  public static <K, V> SortedMap <K,V> checkedSortedMap(SortedMap <K,V> m, Class <K> keyType, Class <V> valueType)
  
  返回指定排序映射的动态类型安全视图。任何尝试插入其键或值具有错误类型的映射都将导致立即 ClassCastException 。类似地，任何修改当前与键关联的值的尝试都将导致立即 ClassCastException ，无论是直接通过映射本身尝试修改，还是通过从映射的 entry set 视图获得的 Map.Entry 实例进行修改。
  假设在生成动态类型安全视图之前映射不包含错误键入的键或值，并且所有后续对映射的访问都是通过视图（或其集合视图之一）进行的，它是保证映射不能包含错误键入的键或值。
  
  可以在 checkedCollection 方法的文档中找到有关使用动态类型安全视图的讨论。
  
  如果指定的map是可序列化的，则返回的map将是可序列化的。
  
  由于 null 被认为是任何引用类型的值，因此无论何时支持map，返回的映射都允许插入空键或值。
  
  类型参数：
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数：
  
  m - 要为其返回动态类型安全视图的映射
  
  keyType - 允许 m 持有的密钥类型
  
  valueType - m 允许持有的值的类型
  
  返回：
  
  指定map的动态类型安全视图
  
  自从：
  
  1.5
- checkedNavigableMap
  
  public static <K, V> NavigableMap <K,V> checkedNavigableMap(NavigableMap <K,V> m, Class <K> keyType, Class <V> valueType)
  
  返回指定可导航map的动态类型安全视图。任何尝试插入其键或值具有错误类型的映射都将导致立即 ClassCastException 。类似地，任何修改当前与键关联的值的尝试都将导致立即 ClassCastException ，无论是直接通过映射本身尝试修改，还是通过从映射的 entry set 视图获得的 Map.Entry 实例进行修改。
  假设在生成动态类型安全视图之前，map不包含错误键入的键或值，并且所有后续对map的访问都是通过视图（或其集合视图之一）进行的，那么 guaranteed map不能包含错误键入的键或值。
  
  可以在 checkedCollection 方法的文档中找到有关使用动态类型安全视图的讨论。
  
  如果指定的map是可序列化的，则返回的map将是可序列化的。
  
  由于 null 被认为是任何引用类型的值，因此无论何时支持map，返回的映射都允许插入空键或值。
  
  类型参数：
  
  K - map键的类型
  
  V - 映射值的类型
  
  参数：
  
  m - 要为其返回动态类型安全视图的映射
  
  keyType - 允许 m 持有的密钥类型
  
  valueType - m 允许持有的值的类型
  
  返回：
  
  指定map的动态类型安全视图
  
  自从：
  
  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 - 集合中元素的类型（如果有的话）
  
  返回：
  
  空的可导航 set
  
  自从：
  
  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（不可变）。该map是可序列化的。
  此示例说明了获取空map的类型安全方法：
  
  Map<String, Date> s = Collections.emptyMap();
  实现注意事项：
  
  此方法的实现无需为每次调用创建单独的 Map 对象。使用此方法的成本可能与使用同名字段的成本相当。（与此方法不同，该字段不提供类型安全。）
  
  类型参数：
  
  K - 映射键的类
  
  V - 映射值的类
  
  返回：
  
  一张空map
  
  自从：
  
  1.5
  
  参见：
  
  EMPTY_MAP
- emptySortedMap
  
  public static final <K, V> SortedMap <K,V> emptySortedMap()
  返回一个空的排序映射（不可变）。该map是可序列化的。
  此示例说明了获取空map的类型安全方法：
  
  SortedMap<String, Date> s = Collections.emptySortedMap();
  实现注意事项：
  
  此方法的实现无需为每次调用创建单独的 SortedMap 对象。
  
  类型参数：
  
  K - 映射键的类
  
  V - 映射值的类
  
  返回：
  
  一个空的排序map
  
  自从：
  
  1.8
- emptyNavigableMap
  
  public static final <K, V> NavigableMap <K,V> emptyNavigableMap()
  返回一个空的可navigable map（不可变）。该map是可序列化的。
  此示例说明了获取空map的类型安全方法：
  
  NavigableMap<String, Date> s = Collections.emptyNavigableMap();
  实现注意事项：
  
  此方法的实现无需为每次调用创建单独的 NavigableMap 对象。
  
  类型参数：
  
  K - 映射键的类
  
  V - 映射值的类
  
  返回：
  
  空的可navigable map
  
  自从：
  
  1.8
- singleton
  
  public static <T> Set <T> singleton(T o)
  
  返回仅包含指定对象的不可变集。返回的集合是可序列化的。
  
  类型参数：
  
  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)
  
  返回一个不可变映射，仅将指定键映射到指定值。返回的map是可序列化的。
  
  类型参数：
  
  K - 映射键的类
  
  V - 映射值的类
  
  参数：
  
  key - 要存储在返回map中的唯一键。
  
  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 接口的对象集合施加 natural ordering 的反转。（自然顺序是由对象自己的 compareTo 方法强加的顺序。）这启用了一个简单的习惯用法，用于排序（或维护）以反向自然顺序实现 Comparable 接口的对象集合（或数组）。例如，假设 a 是一个字符串数组。然后：
  Arrays.sort(a, Collections.reverseOrder());
  以反向词典（字母）顺序对数组进行排序。
  返回的比较器是可序列化的。
  类型参数：
  
  T - 比较器比较的对象的类
  
  返回：
  
  施加相反的比较器自然排序在实现 Comparable 接口的对象集合上。
  
  参见：
  
  Comparable
- reverseOrder
  
  public static <T> Comparator <T> reverseOrder(Comparator <T> cmp)
  
  返回一个比较器，该比较器强加指定比较器的反向排序。如果指定的比较器是 null ，则此方法等效于 reverseOrder() （换句话说，它返回一个比较器，该比较器将 natural ordering 的逆向强加于实现 Comparable 接口的对象集合）。
  返回的比较器是可序列化的（假设指定的比较器也是可序列化的或 null ）。
  
  类型参数：
  
  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)
  
  返回指定集合中等于指定对象的元素数。更正式地说，返回集合中满足 Objects.equals(o, e) 的元素数 e。
  
  参数：
  
  c - 确定 o 频率的集合
  
  o - 待测频率的对象
  
  返回：
  
  c 中的元素数等于 o
  
  抛出：
  
  NullPointerException - 如果 c 为空
  
  自从：
  
  1.5
- disjoint
  
  public static boolean disjoint(Collection <?> c1, Collection <?> c2)
  
  如果两个指定的集合没有共同的元素，则返回 true。
  如果将此方法用于不符合 Collection 的一般合同的集合，则必须小心。实现可以选择迭代任一集合并测试是否包含在另一个集合中（或执行任何等效计算）。如果任一集合使用非标准相等性测试（如排序不是 compatible with equals 的 SortedSet 或 IdentityHashMap 的键集），则两个集合必须使用相同的非标准相等性测试，否则此方法的结果未定义。
  
  在使用对其可能包含的元素有限制的集合时也必须小心。允许集合实现为涉及它们认为不合格的元素的任何操作抛出异常。为了绝对安全，指定的集合应该只包含对两个集合都符合条件的元素。
  
  请注意，允许在两个参数中传递相同的集合，在这种情况下，当且仅当集合为空时，该方法将返回 true。
  
  参数：
  
  c1 - 一个集合
  
  c2 - 一个集合
  
  返回：
  
  true 如果两个指定的集合没有共同的元素。
  
  抛出：
  
  NullPointerException - 如果任一集合是 null 。
  
  NullPointerException - 如果一个集合包含一个 null 元素并且 null 不是另一个集合的合格元素。 (optional)
  
  ClassCastException - 如果一个集合包含一个元素，该元素的类型不适合另一个集合。 (optional)
  
  自从：
  
  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)
  返回由指定map支持的集合。结果集显示与支持map相同的排序、并发性和性能特征。本质上，这个工厂方法提供了一个Set 实现对应于任何Map 实现。无需在已具有相应 Set 实现（例如 HashMap 或 TreeMap ）的 Map 实现上使用此方法。
  此方法返回的集合上的每个方法调用都会导致对支持map或其 keySet 视图的一次方法调用，但有一个例外。 addAll 方法被实现为支持map上的一系列 put 调用。
  
  调用此方法时指定的map必须为空，并且不应在此方法返回后直接访问。如果map创建为空，直接传递给此方法，并且不保留对map的引用，则可以确保这些条件，如以下代码片段所示：
  
  Set<Object> weakHashSet = Collections.newSetFromMap( new WeakHashMap<Object, Boolean>());
  类型参数：
  
  E - 映射键和返回集中对象的类
  
  参数：
  
  map - 支持map
  
  返回：
  
  map支持的集合
  
  抛出：
  
  IllegalArgumentException - 如果 map 不为空
  
  自从：
  
  1.6
- asLifoQueue
  
  public static <T> Queue <T> asLifoQueue(Deque <T> deque)
  
  将 Deque 的视图作为后进先出 (Lifo) Queue 返回。方法 add 映射到 push ，remove 映射到 pop 等等。当您想使用需要 Queue 但需要后进先出排序的方法时，此视图会很有用。
  此方法返回的队列上的每个方法调用都会导致支持双端队列上的一次方法调用，但有一个例外。 addAll 方法被实现为支持双端队列上的一系列 addFirst 调用。
  
  类型参数：
  
  T - 双端队列中对象的类
  
  参数：
  
  deque - 双端队列
  
  返回：
  
  队列
  
  自从：
  
  1.6

类 Collections

字段摘要

方法总结

在类 java.lang.Object 中声明的方法

字段详细信息

EMPTY_SET

EMPTY_LIST

EMPTY_MAP

方法详情

sort

sort

binarySearch

binarySearch

reverse

shuffle

shuffle

swap

fill

copy

min

min

max

max

rotate

replaceAll

indexOfSubList

lastIndexOfSubList

unmodifiableCollection

unmodifiableSet

unmodifiableSortedSet

unmodifiableNavigableSet

unmodifiableList

unmodifiableMap

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

asLifoQueue