鸿蒙OS Collections

Collections

java.lang.Object

|—java.util.Collections

public class Collections
extends Object

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

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

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

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

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

字段摘要

方法总结

字段详细信息

EMPTY_LIST

public static final List EMPTY_LIST

空列表（不可变）。 这个列表是可序列化的。

EMPTY_MAP

public static final Map EMPTY_MAP

空地图（不可变）。 该地图是可序列化的。

EMPTY_SET

public static final Set EMPTY_SET

空集（不可变）。 这个集合是可序列化的。

方法详情

sort

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

根据其元素的 Comparable 对指定列表进行升序排序。 列表中的所有元素都必须实现 Comparable 接口。 此外，列表中的所有元素必须相互可比较（即，e1.compareTo(e2) 不得为列表中的任何元素 e1 和 e2 抛出 ClassCastException）。

这种排序保证是稳定的：相同的元素不会因为排序而重新排序。

指定的列表必须是可修改的，但不必调整大小。

类型参数：

参数:

Throws:

sort

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

根据指定比较器产生的顺序对指定列表进行排序。 列表中的所有元素必须使用指定的比较器进行相互比较（即，c.compare(e1, e2) 不得为列表中的任何元素 e1 和 e2 抛出 ClassCastException）。

这种排序保证是稳定的：相同的元素不会因为排序而重新排序。

指定的列表必须是可修改的，但不必调整大小。

类型参数：

参数:

Throws:

binarySearch

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

使用二分搜索算法在指定列表中搜索指定对象。 在进行此调用之前，必须根据其元素的 Comparable 对列表进行升序排序（如通过 sort(java.util.List) 方法）。 如果未排序，则结果未定义。 如果列表包含多个等于指定对象的元素，则无法保证会找到哪一个。

此方法在 log(n) 时间内针对“随机访问”列表（提供接近恒定时间的位置访问）运行。 如果指定的列表没有实现 RandomAccess 接口并且很大，则此方法将执行基于迭代器的二进制搜索，执行 O(n) 链接遍历和 O(log n) 元素比较。

类型参数：

参数:

返回:

搜索关键字的索引，如果它包含在列表中； 否则，（-（插入点）- 1）。 插入点定义为将键插入列表的点：第一个元素的索引大于键，如果列表中的所有元素都小于指定的键，则为 list.size()。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

Throws:

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) 元素比较。

类型参数：

参数:

返回:

搜索关键字的索引，如果它包含在列表中； 否则，（-（插入点）- 1）。 插入点定义为将键插入列表的点：第一个元素的索引大于键，如果列表中的所有元素都小于指定的键，则为 list.size()。 请注意，这保证了当且仅当找到键时，返回值将 >= 0。

Throws:

reverse

public static void reverse(List<?> list)

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

此方法以线性时间运行。

参数：

Throws:

shuffle

public static void shuffle(List<?> list)

使用默认随机源随机排列指定列表。所有排列都以大致相等的可能性发生。

在前面的描述中使用了“大约”对冲，因为默认随机源只是大约独立选择位的无偏源。如果它是随机选择的比特的完美来源，那么该算法将选择具有完美一致性的排列。

此实现从最后一个元素到第二个元素向后遍历列表，反复将随机选择的元素交换到“当前位置”。元素是从列表中从第一个元素到当前位置（含）的部分中随机选择的。

此方法以线性时间运行。如果指定列表没有实现 RandomAccess 接口并且很大，则此实现在打乱之前将指定列表转储到数组中，并将打乱后的数组转储回列表中。这避免了因将“顺序访问”列表改组而导致的二次行为。

参数：

Throws:

shuffle

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

使用指定的随机源随机排列指定的列表。 假设随机性的来源是公平的，所有排列都以相同的可能性发生。

此实现从最后一个元素到第二个元素向后遍历列表，反复将随机选择的元素交换到“当前位置”。 元素是从列表中从第一个元素到当前位置（含）的部分中随机选择的。

此方法以线性时间运行。 如果指定列表没有实现 RandomAccess 接口并且很大，则此实现在打乱之前将指定列表转储到数组中，并将打乱后的数组转储回列表中。 这避免了因将“顺序访问”列表改组而导致的二次行为。

参数：

Throws:

swap

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

交换指定列表中指定位置的元素。 （如果指定的位置相等，则调用此方法会使列表保持不变。）

参数：

Throws:

fill

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

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

此方法以线性时间运行。

类型参数：

参数:

Throws:

copy

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

将一个列表中的所有元素复制到另一个列表中。 操作后，目标列表中每个复制元素的索引将与其在源列表中的索引相同。 目标列表必须至少与源列表一样长。 如果它更长，则目标列表中的其余元素不受影响。

此方法以线性时间运行。

类型参数：

参数:

Throws:

min

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

根据元素的自然顺序返回给定集合的最小元素。 集合中的所有元素都必须实现 Comparable 接口。 此外，集合中的所有元素必须相互可比较（即，e1.compareTo(e2) 不得为集合中的任何元素 e1 和 e2 抛出 ClassCastException）。

此方法迭代整个集合，因此它需要与集合大小成正比的时间。

类型参数：

参数:

返回:

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

Throws:

min

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

根据指定比较器诱导的顺序返回给定集合的最小元素。 集合中的所有元素必须通过指定的比较器相互比较（即，comp.compare(e1, e2) 不得为集合中的任何元素 e1 和 e2 抛出 ClassCastException）。

此方法迭代整个集合，因此它需要与集合大小成正比的时间。

类型参数：

参数:

返回:

根据指定的比较器，给定集合的最小元素。

Throws:

max

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

根据元素的自然顺序返回给定集合的最大元素。 集合中的所有元素都必须实现 Comparable 接口。 此外，集合中的所有元素必须相互可比较（即，e1.compareTo(e2) 不得为集合中的任何元素 e1 和 e2 抛出 ClassCastException）。

此方法迭代整个集合，因此它需要与集合大小成正比的时间。

类型参数：

参数:

返回:

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

Throws:

max

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

根据指定比较器诱导的顺序返回给定集合的最大元素。 集合中的所有元素必须通过指定的比较器相互比较（即，comp.compare(e1, e2) 不得为集合中的任何元素 e1 和 e2 抛出 ClassCastException）。

此方法迭代整个集合，因此它需要与集合大小成正比的时间。

类型参数：

参数:

返回:

根据指定的比较器，给定集合的最大元素。

Throws:

rotate

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

将指定列表中的元素旋转指定距离。 调用此方法后，索引 i 处的元素将是先前位于索引 (i – 距离) mod list.size() 处的元素，对于 i 的所有值介于 0 和 list.size()-1 之间，包括 0 和 list.size()-1。 （此方法对列表的大小没有影响。）

例如，假设列表包含 [t, a, n, k, s]。 调用 Collections.rotate(list, 1)（或 Collections.rotate(list, -4)）后，列表将包含 [s, t, a, n, k]。

请注意，此方法可以有效地应用于子列表，以在列表中移动一个或多个元素，同时保留剩余元素的顺序。 例如，以下习惯用法将索引 j 处的元素向前移动到位置 k（必须大于或等于 j）：

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

为了具体说明，假设列表包含 [a, b, c, d, e]。 要将索引 1 (b) 处的元素向前移动两个位置，请执行以下调用：

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

结果列表是 [a, c, d, b, e]。

要向前移动多个元素，请增加旋转距离的绝对值。要向后移动元素，请使用正偏移距离。

如果指定的列表很小或实现了 RandomAccess 接口，则此实现将第一个元素交换到它应该去的位置，然后重复地将被替换的元素交换到它应该去的位置，直到一个被替换的元素被交换到第一个元素。如有必要，对第二个和后续元素重复该过程，直到旋转完成。如果指定的列表很大并且没有实现 RandomAccess 接口，则此实现将列表分成两个围绕 index -distance mod 大小的子列表视图。然后在每个子列表视图上调用 reverse(java.util.List) 方法，最后在整个列表上调用它。

参数：

Throws:

replaceAll

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

将列表中一个指定值的所有出现替换为另一个。 更正式地说，用 newVal 替换列表中的每个元素 e，使得 (oldVal==null ? e==null : oldVal.equals(e))。 （此方法对列表的大小没有影响。）

类型参数：

参数:

返回:

如果 list 包含一个或多个元素 e 满足 (oldVal==null ? e==null : oldVal.equals(e))，则为 true。

Throws:

indexOfSubList

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

返回指定源列表中指定目标列表第一次出现的起始位置，如果没有出现，则返回 -1。 更正式地说，返回满足 source.subList(i, i+target.size()).equals(target) 的最低索引 i，如果没有这样的索引，则返回 -1。 （如果 target.size() > source.size() 则返回 -1）

此实现使用扫描源列表的“brute force”技术，依次在每个位置寻找与目标的匹配。

参数：

返回:

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

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）

该实现使用“brute force”技术迭代源列表，依次在每个位置寻找与目标的匹配。

参数：

返回:

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

unmodifiableCollection

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

返回指定集合的不可修改视图。 此方法允许模块为用户提供对内部集合的“只读”访问权限。 对返回集合的查询操作“通读”到指定集合，并尝试修改返回的集合，无论是直接还是通过其迭代器，都会导致 UnsupportedOperationException。

返回的集合不会将 hashCode 和 equals 操作传递给支持集合，而是依赖于 Object 的 equals 和 hashCode 方法。 在支持集合是集合或列表的情况下，这对于保留这些操作的合同是必要的。

如果指定的集合是可序列化的，则返回的集合将是可序列化的。

类型参数：

参数:

返回:

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

unmodifiableSet

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

返回指定集合的不可修改视图。 此方法允许模块为用户提供对内部集的“只读”访问权限。 对返回集“通读”到指定集的查询操作，并尝试修改返回集，无论是直接还是通过其迭代器，都会导致 UnsupportedOperationException。

如果指定的集合是可序列化的，则返回的集合将是可序列化的。

类型参数：

参数:

返回:

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

unmodifiableSortedSet

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

返回指定排序集的不可修改视图。 此方法允许模块为用户提供对内部排序集的“只读”访问权限。 对返回的排序集的查询操作“通读”到指定的排序集。 尝试修改返回的排序集，无论是直接的、通过它的迭代器，还是通过它的 subSet、headSet 或 tailSet 视图，都会导致 UnsupportedOperationException。

如果指定的排序集是可序列化的，则返回的排序集将是可序列化的。

类型参数：

参数:

返回:

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

unmodifiableNavigableSet

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

返回指定导航集的不可修改视图。 此方法允许模块为用户提供对内部可导航集的“只读”访问权限。 对返回的导航集的查询操作“通读”到指定的导航集。 尝试修改返回的可导航集，无论是直接、通过其迭代器，还是通过其子集、头集或尾集视图，都会导致 UnsupportedOperationException。

如果指定的导航集是可序列化的，则返回的导航集将是可序列化的。

类型参数：

参数:

返回:

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

unmodifiableList

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

返回指定列表的不可修改视图。 此方法允许模块为用户提供对内部列表的“只读”访问权限。 对返回列表的查询操作“通读”到指定列表，并尝试修改返回的列表，无论是直接还是通过其迭代器，都会导致 UnsupportedOperationException。

如果指定的列表是可序列化的，则返回的列表将是可序列化的。 同样，如果指定的列表执行，则返回的列表将实现 RandomAccess。

类型参数：

参数:

返回:

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

unmodifiableMap

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

返回指定地图的不可修改视图。 此方法允许模块为用户提供对内部地图的“只读”访问权限。 对返回的映射“通读”到指定映射的查询操作，并尝试修改返回的映射，无论是直接还是通过其集合视图，都会导致 UnsupportedOperationException。

如果指定的映射是可序列化的，则返回的映射将是可序列化的。

类型参数：

参数:

返回:

指定map的不可修改视图。

unmodifiableSortedMap

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

返回指定排序地图的不可修改视图。 此方法允许模块为用户提供对内部排序地图的“只读”访问权限。 对返回的有序映射的查询操作“通读”到指定的有序映射。 尝试修改返回的排序地图，无论是直接的、通过它的集合视图，还是通过它的 subMap、headMap 或 tailMap 视图，都会导致 UnsupportedOperationException。

如果指定的排序映射是可序列化的，则返回的排序映射将是可序列化的。

类型参数：

参数:

返回:

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

unmodifiableNavigableMap

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

返回指定导航地图的不可修改视图。 此方法允许模块为用户提供对内部可导航地图的“只读”访问权限。 对返回的导航地图的查询操作“通读”到指定的导航地图。 尝试修改返回的可导航地图，无论是直接通过其集合视图，还是通过其 subMap、headMap 或 tailMap 视图，都会导致 UnsupportedOperationException。

如果指定的导航地图是可序列化的，则返回的导航地图将是可序列化的。

类型参数：

参数:

返回:

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

synchronizedCollection

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 操作传递给支持集合，而是依赖于 Object 的 equals 和 hashCode 方法。 在支持集合是集合或列表的情况下，这对于保留这些操作的合同是必要的。

如果指定的集合是可序列化的，则返回的集合将是可序列化的。

类型参数：

参数:

返回:

指定集合的同步视图。

synchronizedSet

public static <T> Set<T> synchronizedSet(Set<T> s)

返回由指定集支持的同步（线程安全）集。 为了保证串行访问，对支持集的所有访问都是通过返回集完成的，这一点至关重要。

当迭代它时，用户必须在返回的集合上手动同步：

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

不遵循此建议可能会导致不确定的行为。

如果指定的集合是可序列化的，则返回的集合将是可序列化的。

类型参数：

参数:

返回:

指定集合的同步视图。

synchronizedSortedSet

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

返回由指定排序集支持的同步（线程安全）排序集。 为了保证串行访问，对后备排序集的所有访问都是通过返回的排序集（或其视图）完成的，这一点至关重要。

当迭代返回的排序集或其任何子集、头集或尾集视图时，用户必须手动同步返回的排序集。

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

不遵循此建议可能会导致不确定的行为。

如果指定的排序集是可序列化的，则返回的排序集将是可序列化的。

类型参数：

参数:

返回:

指定排序集的同步视图。

synchronizedNavigableSet

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

返回由指定导航集支持的同步（线程安全）导航集。 为了保证串行访问，对支持导航集的所有访问都是通过返回的导航集（或其视图）完成的，这一点至关重要。

当迭代返回的可导航集或其任何子集、头集或尾集视图时，用户必须手动同步返回的可导航集。

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

不遵循此建议可能会导致不确定的行为。

如果指定的导航集是可序列化的，则返回的导航集将是可序列化的。

类型参数：

参数:

返回:

指定导航集的同步视图

synchronizedList

public static <T> List<T> synchronizedList(List<T> list)

返回由指定列表支持的同步（线程安全）列表。 为了保证串行访问，对后备列表的所有访问都通过返回的列表完成是至关重要的。

用户在迭代返回的列表时必须手动同步它：

  List list = Collections.synchronizedList(new ArrayList());
      ...
  synchronized (list) {
      Iterator i = list.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }

不遵循此建议可能会导致不确定的行为。

如果指定的列表是可序列化的，则返回的列表将是可序列化的。

类型参数：

参数:

返回:

指定列表的同步视图。

synchronizedMap

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)

返回由指定映射支持的同步（线程安全）映射。 为了保证串行访问，对支持映射的所有访问都是通过返回的映射完成的，这一点至关重要。

当迭代其任何集合视图时，用户必须在返回的地图上手动同步：

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

不遵循此建议可能会导致不确定的行为。

如果指定的映射是可序列化的，则返回的映射将是可序列化的。

类型参数：

参数:

Returns:

a synchronized view of the specified map.

synchronizedSortedMap

public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)

返回由指定排序映射支持的同步（线程安全）排序映射。 为了保证串行访问，对后备排序映射的所有访问都是通过返回的排序映射（或其视图）完成的，这一点至关重要。

当迭代其任何集合视图或其任何 subMap、headMap 或 tailMap 视图的集合视图时，用户必须在返回的排序地图上手动同步。

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

或者:

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

不遵循此建议可能会导致不确定的行为。

如果指定的排序映射是可序列化的，则返回的排序映射将是可序列化的。

类型参数：

参数:

返回:

指定排序map的同步视图。

synchronizedNavigableMap

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

不遵循此建议可能会导致不确定的行为。

如果指定的导航地图是可序列化的，则返回的导航地图将是可序列化的。

类型参数：

参数:

返回:

指定导航map的同步视图。

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 元素。

类型参数：

参数:

返回:

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

checkedQueue

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

返回指定队列的动态类型安全视图。 任何插入错误类型元素的尝试都将立即导致 ClassCastException。 假设在生成动态类型安全视图之前队列不包含类型错误的元素，并且所有后续对队列的访问都通过视图进行，则可以保证队列不会包含类型错误的元素。

可以在 checkedCollection 方法的文档中找到有关使用动态类型安全视图的讨论。

如果指定的队列是可序列化的，则返回的队列将是可序列化的。

由于 null 被认为是任何引用类型的值，因此返回的队列允许在后备队列中插入 null 元素。

类型参数：

参数:

返回:

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

checkedSet

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

返回指定集合的动态类型安全视图。 任何插入错误类型元素的尝试都将立即导致 ClassCastException。 假设在生成动态类型安全视图之前，集合不包含错误类型的元素，并且所有后续访问该集合都通过该视图进行，则可以保证该集合不能包含错误类型的元素。

可以在 checkedCollection 方法的文档中找到有关使用动态类型安全视图的讨论。

如果指定的集合是可序列化的，则返回的集合将是可序列化的。

由于 null 被认为是任何引用类型的值，因此只要支持集插入，返回的集合就允许插入 null 元素。

类型参数：

参数:

返回:

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

checkedSortedSet

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

返回指定排序集的动态类型安全视图。 任何插入错误类型元素的尝试都将立即导致 ClassCastException。 假设在生成动态类型安全视图之前，排序集不包含类型错误的元素，并且所有后续对排序集的访问都通过视图进行，则可以保证排序集不会包含类型错误的元素。

可以在 checkedCollection 方法的文档中找到有关使用动态类型安全视图的讨论。

如果指定的排序集是可序列化的，则返回的排序集将是可序列化的。

由于 null 被认为是任何引用类型的值，因此返回的排序集允许在支持排序集插入时插入 null 元素。

类型参数：

参数:

返回:

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

checkedNavigableSet

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

返回指定导航集的动态类型安全视图。 任何插入错误类型元素的尝试都将立即导致 ClassCastException。 假设在生成动态类型安全视图之前，可导航集不包含类型错误的元素，并且所有后续访问可导航集都通过视图进行，则可以保证可导航集不能包含错误类型的元素。

可以在 checkedCollection 方法的文档中找到有关使用动态类型安全视图的讨论。

如果指定的导航集是可序列化的，则返回的导航集将是可序列化的。

由于 null 被认为是任何引用类型的值，因此返回的可导航集允许在支持排序集插入时插入 null 元素。

类型参数：

参数:

返回:

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

checkedList

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

返回指定列表的动态类型安全视图。 任何插入错误类型元素的尝试都将立即导致 ClassCastException。 假设在生成动态类型安全视图之前列表不包含错误类型的元素，并且所有后续访问列表都通过视图进行，则可以保证列表不能包含错误类型的元素。

可以在 checkedCollection 方法的文档中找到有关使用动态类型安全视图的讨论。

如果指定的列表是可序列化的，则返回的列表将是可序列化的。

由于 null 被认为是任何引用类型的值，因此返回的列表允许在后备列表中插入 null 元素。

类型参数：

参数:

返回:

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

checkedMap

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

返回指定映射的动态类型安全视图。任何插入其键或值类型错误的映射的尝试都将立即导致 ClassCastException。类似地，任何修改当前与键关联的值的尝试都将立即导致 ClassCastException，无论是直接通过映射本身尝试修改，还是通过从映射的 Map#entrySet() 视图获得的 Map.Entry 实例。

假设在生成动态类型安全视图之前，映射不包含错误类型的键或值，并且所有后续对映射的访问都通过视图（或其集合视图之一）进行，则可以保证映射不能包含键入错误的键或值。

可以在 checkedCollection 方法的文档中找到有关使用动态类型安全视图的讨论。

如果指定的映射是可序列化的，则返回的映射将是可序列化的。

由于 null 被认为是任何引用类型的值，因此返回的映射允许在支持映射时插入空键或值。

类型参数：

参数:

返回:

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

checkedSortedMap

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

返回指定排序映射的动态类型安全视图。任何插入其键或值类型错误的映射的尝试都将立即导致 ClassCastException。类似地，任何修改当前与键关联的值的尝试都将立即导致 ClassCastException，无论是直接通过映射本身尝试修改，还是通过从映射的 Map#entrySet() 视图获得的 Map.Entry 实例。

假设在生成动态类型安全视图之前，映射不包含错误类型的键或值，并且所有后续对映射的访问都通过视图（或其集合视图之一）进行，则可以保证映射不能包含键入错误的键或值。

可以在 checkedCollection 方法的文档中找到有关使用动态类型安全视图的讨论。

如果指定的映射是可序列化的，则返回的映射将是可序列化的。

由于 null 被认为是任何引用类型的值，因此返回的映射允许在支持映射时插入空键或值。

类型参数：

参数:

返回:

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

checkedNavigableMap

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

返回指定可导航地图的动态类型安全视图。任何插入其键或值类型错误的映射的尝试都将立即导致 ClassCastException。类似地，任何修改当前与键关联的值的尝试都将立即导致 ClassCastException，无论是直接通过映射本身尝试修改，还是通过从映射的 Map#entrySet() 视图获得的 Map.Entry 实例。

假设在生成动态类型安全视图之前，映射不包含错误类型的键或值，并且所有后续对映射的访问都通过视图（或其集合视图之一）进行，则可以保证映射不能包含键入错误的键或值。

可以在 checkedCollection 方法的文档中找到有关使用动态类型安全视图的讨论。

如果指定的映射是可序列化的，则返回的映射将是可序列化的。

由于 null 被认为是任何引用类型的值，因此返回的映射允许在支持映射时插入空键或值。

类型参数：

参数:

返回:

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

emptyIterator

public static <T> Iterator<T> emptyIterator()

返回一个没有元素的迭代器。 更确切地说，

• Iterator#hasNext 总是返回 false。
• Iterator#next 总是抛出 NoSuchElementException。
• Iterator#remove 总是抛出 IllegalStateException。

允许但不要求此方法的实现从多次调用中返回相同的对象。

类型参数：

返回:

一个空的迭代器

emptyListIterator

public static <T> ListIterator<T> emptyListIterator()

返回一个没有元素的列表迭代器。 更确切地说，

• Iterator#hasNext 和 ListIterator#hasPrevious 总是返回 false。
• Iterator#next 和 ListIterator#previous 总是抛出 NoSuchElementException。
• Iterator#remove 和 ListIterator#set 总是抛出 IllegalStateException。
• ListIterator#add 总是抛出 UnsupportedOperationException。
• ListIterator#nextIndex 总是返回 0。
• ListIterator#previousIndex 总是返回 -1。

允许但不要求此方法的实现从多次调用中返回相同的对象。

类型参数：

返回:

一个空列表迭代器

emptyEnumeration

public static <T> Enumeration<T> emptyEnumeration()

返回一个没有元素的枚举。 更确切地说，

• Enumeration#hasMoreElements 总是返回 false。
• Enumeration#nextElement 总是抛出 NoSuchElementException。

允许但不要求此方法的实现从多次调用中返回相同的对象。

类型参数：

返回:

空枚举

emptySet

public static final <T> Set<T> emptySet()

返回一个空集（不可变）。 这个集合是可序列化的。 与同名字段不同，此方法是参数化的。

此示例说明了获取空集的类型安全方法：

     Set<String> s = Collections.emptySet(); 

类型参数:

返回:

空集

emptySortedSet

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

返回一个空的排序集（不可变）。 这个集合是可序列化的。

此示例说明了获取空排序集的类型安全方法：

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

类型参数:

返回:

空排序集

emptyNavigableSet

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

返回一个空的可导航集（不可变）。 这个集合是可序列化的。

此示例说明了获取空可导航集的类型安全方法：

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

类型参数:

返回:

空的可导航集

emptyList

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

返回一个空列表（不可变）。 这个列表是可序列化的。

此示例说明了获取空列表的类型安全方法：

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

类型参数:

返回:

一个空的不可变列表

emptyMap

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

返回一个空映射（不可变）。 该地图是可序列化的。

此示例说明了获取空映射的类型安全方法：

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

类型参数:

返回:

空map

emptySortedMap

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

返回一个空的排序映射（不可变）。 该map是可序列化的。

此示例说明了获取空映射的类型安全方法：

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

类型参数:

返回:

一个空的排序map

emptyNavigableMap

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

返回一个空的可导航map（不可变）。 该map是可序列化的。

此示例说明了获取空映射的类型安全方法：

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

类型参数:

返回:

空的可导航map

singleton

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

返回一个只包含指定对象的不可变集合。 返回的集合是可序列化的。

类型参数：

参数:

返回:

只包含指定对象的不可变集合。

singletonList

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

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

类型参数：

参数:

返回:

只包含指定对象的不可变列表。

singletonMap

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

返回一个不可变映射，仅将指定的键映射到指定的值。 返回的map是可序列化的。

类型参数：

参数:

返回:

只包含指定键值映射的不可变映射。

nCopies

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

返回由指定对象的 n 个副本组成的不可变列表。 新分配的数据对象很小（它包含对数据对象的单个引用）。 此方法与 List.addAll 方法结合使用可增加列表。 返回的列表是可序列化的。

类型参数：

参数:

返回:

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

Throws:

reverseOrder

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

返回一个比较器，它对实现 Comparable 接口的对象集合施加自然顺序的逆向。 （自然排序是对象自己的 compareTo 方法强加的排序。）这实现了一个简单的习惯用法，用于排序（或维护）以反向自然顺序实现 Comparable 接口的对象集合（或数组）。 例如，假设 a 是一个字符串数组。 然后：

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

以反向字典（字母）顺序对数组进行排序。

返回的比较器是可序列化的。

类型参数：

返回:

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

reverseOrder

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

返回一个比较器，它强制指定比较器的反向排序。 如果指定的比较器为 null，则此方法等效于 reverseOrder()（换句话说，它返回一个比较器，该比较器将自然排序的反向强加于实现 Comparable 接口的对象集合）。

返回的比较器是可序列化的（假设指定的比较器也是可序列化的或为空）。

类型参数：

参数:

返回:

一个比较器，它强制指定比较器的反向排序。

enumeration

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

返回指定集合的枚举。 这提供了与需要枚举作为输入的旧 API 的互操作性。

类型参数：

参数:

返回:

对指定集合的枚举。

list

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

按枚举返回的顺序返回一个数组列表，其中包含指定枚举返回的元素。 此方法提供了返回枚举的旧 API 和需要集合的新 API 之间的互操作性。

类型参数：

参数:

返回:

包含指定枚举返回的元素的数组列表。

frequency

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

返回指定集合中等于指定对象的元素数。 更正式地说，返回集合中元素 e 的数量，使得 (o == null ? e == null : o.equals(e))。

参数：

返回:

c 中的元素个数等于 o

Throws:

disjoint

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

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

如果将此方法用于不符合收集总合同的收集，则必须小心。实现可以选择迭代任一集合并测试另一个集合中的包含（或执行任何等效计算）。如果任一集合使用非标准相等测试（如排序与 equals 不兼容的 SortedSet 或 IdentityHashMap 的键集），则两个集合必须使用相同的非标准相等测试，否则此方法的结果未定义。

在使用对它们可能包含的元素有限制的集合时，还必须小心。允许集合实现为涉及他们认为不合格的元素的任何操作抛出异常。为了绝对安全，指定的集合应仅包含对两个集合都符合条件的元素。

请注意，允许在两个参数中传递相同的集合，在这种情况下，当且仅当集合为空时，该方法才会返回 true。

参数：

返回:

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

Throws:

addAll

@SafeVarargs public static <T> boolean addAll(Collection<? super T> c, T… elements)

将所有指定元素添加到指定集合。 要添加的元素可以单独指定，也可以作为数组指定。 此便捷方法的行为与 c.addAll(Arrays.asList(elements)) 的行为相同，但此方法在大多数实现下可能运行得更快。

当单独指定元素时，此方法提供了一种将一些元素添加到现有集合的便捷方法：

     Collections.addAll(flavors, "Peaches 'n Plutonium", "Rocky Racoon"); 

类型参数:

参数:

返回:

如果集合因调用而更改，则为 true

Throws:

newSetFromMap

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

返回由指定映射支持的集合。 结果集显示与支持映射相同的排序、并发性和性能特征。 本质上，这个工厂方法提供了一个对应于任何 Map 实现的 Set 实现。 没有必要在已经有对应 Set 实现的 Map 实现上使用该方法（例如 HashMap 或 TreeMap）。

对此方法返回的集合的每个方法调用都会导致对支持映射或其 keySet 视图的一个方法调用，但有一个例外。 addAll 方法被实现为支持映射上的一系列 put 调用。

调用此方法时指定的映射必须为空，并且不应在此方法返回后直接访问。 如果地图创建为空，直接传递给此方法，并且不保留对地图的引用，则可以确保这些条件，如以下代码片段所示：

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

类型参数:

参数:

返回:

map支持的集合

Throws:

asLifoQueue

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

将 Deque 的视图返回为后进先出 (Lifo) 队列。 方法 add 映射到 push，remove 映射到 pop 等等。 当您想使用需要队列但需要 Lifo 排序的方法时，此视图可能很有用。

此方法返回的队列上的每个方法调用都会导致后备双端队列上的方法调用只有一个，但有一个例外。 Queue#addAll 方法被实现为支持双端队列上的一系列 Deque#addFirst 调用。

类型参数：

参数:

返回:

队列