public class Collections extends Object
如果提供给它们的集合或类对象为null，则此类的方法都抛出一个NullPointerException 。
该类中包含的多态算法的文档通常包括实现的简要说明 。 这些描述应被视为实施说明 ，而不是说明书的一部分 。 只要规范本身得到遵守，实现者就可以随意替代其他算法。 （例如，sort使用的算法不一定是一个mergeesort，但它必须是稳定的 。）
如果集合不支持适当的突变原语，例如set方法，则该类中包含的“破坏性”算法，即修改其操作的集合的算法被指定为抛出UnsupportedOperationException 。 如果调用对集合没有影响，这些算法可能但不是必须抛出此异常。 例如，在已经排序的不可修改列表上调用sort方法可以抛出UnsupportedOperationException 。
Collection ， Set ， List ， Map
| Modifier and Type | Field and Description |
|---|---|
static List |
EMPTY_LIST
空列表（不可变）。
|
static Map |
EMPTY_MAP
空地图（immutable）。
|
static Set |
EMPTY_SET
空集（不可变）。
|
| Modifier and Type | Method and Description |
|---|---|
static <T> boolean |
addAll(Collection<? super T> c, T... elements)
将所有指定的元素添加到指定的集合。
|
static <T> Queue<T> |
asLifoQueue(Deque<T> deque)
|
static <T> int |
binarySearch(List<? extends Comparable<? super T>> list, T key)
使用二叉搜索算法搜索指定对象的指定列表。
|
static <T> int |
binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
使用二叉搜索算法搜索指定对象的指定列表。
|
static <E> Collection<E> |
checkedCollection(Collection<E> c, 类<E> type)
返回指定集合的动态类型安全视图。
|
static <E> List<E> |
checkedList(List<E> list, 类<E> type)
返回指定列表的动态类型安全视图。
|
static <K,V> Map<K,V> |
checkedMap(Map<K,V> m, 类<K> keyType, 类<V> valueType)
返回指定地图的动态类型安全视图。
|
static <K,V> NavigableMap<K,V> |
checkedNavigableMap(NavigableMap<K,V> m, 类<K> keyType, 类<V> valueType)
返回指定可导航地图的动态类型安全视图。
|
static <E> NavigableSet<E> |
checkedNavigableSet(NavigableSet<E> s, 类<E> type)
返回指定的可导航集的动态类型安全视图。
|
static <E> Queue<E> |
checkedQueue(Queue<E> queue, 类<E> type)
返回指定队列的动态类型安全视图。
|
static <E> Set<E> |
checkedSet(Set<E> s, 类<E> type)
返回指定集合的动态类型安全视图。
|
static <K,V> SortedMap<K,V> |
checkedSortedMap(SortedMap<K,V> m, 类<K> keyType, 类<V> valueType)
返回指定排序映射的动态类型安全视图。
|
static <E> SortedSet<E> |
checkedSortedSet(SortedSet<E> s, 类<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 <T> List<T> |
emptyList()
返回空列表（immutable）。
|
static <T> ListIterator<T> |
emptyListIterator()
返回没有元素的列表迭代器。
|
static <K,V> Map<K,V> |
emptyMap()
返回空的地图（不可变）。
|
static <K,V> NavigableMap<K,V> |
emptyNavigableMap()
返回空导航地图（不可变）。
|
static <E> NavigableSet<E> |
emptyNavigableSet()
返回一个空导航集（immutable）。
|
static <T> Set<T> |
emptySet()
返回一个空集（immutable）。
|
static <K,V> SortedMap<K,V> |
emptySortedMap()
返回空的排序映射（immutable）。
|
static <E> SortedSet<E> |
emptySortedSet()
返回一个空的排序集（immutable）。
|
static <T> Enumeration<T> |
enumeration(Collection<T> c)
返回指定集合的枚举。
|
static <T> void |
fill(List<? super T> list, T obj)
用指定的元素代替指定列表的所有元素。
|
static int |
frequency(Collection<?> c, Object o)
返回指定集合中与指定对象相等的元素数。
|
static int |
indexOfSubList(List<?> source, List<?> target)
返回指定源列表中指定目标列表的第一次出现的起始位置，如果没有此类事件，则返回-1。
|
static int |
lastIndexOfSubList(List<?> source, List<?> target)
返回指定源列表中指定目标列表的最后一次出现的起始位置，如果没有此类事件则返回-1。
|
static <T> ArrayList<T> |
list(Enumeration<T> e)
返回一个数组列表，其中包含由枚举返回的顺序由指定的枚举返回的元素。
|
static <T extends Object & Comparable<? super T>> |
max(Collection<? extends T> coll)
根据其元素的
自然顺序返回给定集合的最大元素。
|
static <T> T |
max(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定的比较器引发的顺序返回给定集合的最大元素。
|
static <T extends Object & Comparable<? super T>> |
min(Collection<? extends T> coll)
根据其元素的
自然顺序返回给定集合的最小元素。
|
static <T> T |
min(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定的比较器引发的顺序返回给定集合的最小元素。
|
static <T> List<T> |
nCopies(int n, T o)
返回由指定对象的
n副本组成的不可变列表。
|
static <E> Set<E> |
newSetFromMap(Map<E,Boolean> map)
返回由指定地图支持的集合。
|
static <T> boolean |
replaceAll(List<T> list, T oldVal, T newVal)
将列表中一个指定值的所有出现替换为另一个。
|
static void |
reverse(List<?> list)
反转指定列表中元素的顺序。
|
static <T> Comparator<T> |
reverseOrder()
返回一个比较器，它对实现
Comparable接口的对象集合施加了
自然排序的相反。
|
static <T> Comparator<T> |
reverseOrder(Comparator<T> cmp)
返回一个比较器，它强制指定比较器的反向排序。
|
static void |
rotate(List<?> list, int distance)
将指定列表中的元素旋转指定的距离。
|
static void |
shuffle(List<?> list)
使用默认的随机源随机排列指定的列表。
|
static void |
shuffle(List<?> list, Random rnd)
使用指定的随机源随机排列指定的列表。
|
static <T> Set<T> |
singleton(T o)
返回一个只包含指定对象的不可变集。
|
static <T> List<T> |
singletonList(T o)
返回一个只包含指定对象的不可变列表。
|
static <K,V> Map<K,V> |
singletonMap(K key, V value)
返回一个不可变的地图，只将指定的键映射到指定的值。
|
static <T extends Comparable<? super T>> |
sort(List<T> list)
根据其元素的natural ordering对指定的列表进行排序。
|
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> Set<T> |
unmodifiableSet(Set<? extends T> s)
返回指定集合的不可修改视图。
|
static <K,V> SortedMap<K,V> |
unmodifiableSortedMap(SortedMap<K,? extends V> m)
返回指定排序映射的不可修改视图。
|
static <T> SortedSet<T> |
unmodifiableSortedSet(SortedSet<T> s)
返回指定排序集的不可修改视图。
|
public static final Set EMPTY_SET
emptySet()
public static final List EMPTY_LIST
emptyList()
public static final Map EMPTY_MAP
emptyMap()
public static <T extends Comparable<? super T>> void sort(List<T> list)
Comparable接口。
此外，列表中的所有元素都必须相互可比较 （即e1.compareTo(e2)不能为ClassCastException中的任何元素e1和e2 ）。
这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
指定的列表必须是可修改的，但不能调整大小。
实现注意事项：这个实现是一个稳定的，自适应的，迭代的mergeesort，当输入数组被部分排序时，需要比n lg（n）的比较少得多，同时在输入数组被随机排列时提供传统的mergeesort的性能。 如果输入数组几乎被排序，则实现需要大致n个比较。 临时存储要求从几乎排序的输入数组的小常数到随机排序的输入数组的n / 2对象引用。
该实现在其输入数组中具有上升和下降的同等优势，并且可以在同一输入数组的不同部分中利用升序和降序。 它非常适合合并两个或多个排序的数组：简单地连接数组并排序生成的数组。
实施从Tim Peters的Python列表排序（ TimSort ）进行了改编 。 它使用Peter McIlroy的“乐观排序和信息理论复杂性”中的技术，在第四届ACM-SIAM离散算法研讨会论文集，pp 467-474，1993年1月。
该实现将指定的列表转储到数组中，对数组进行排序，并在列表中迭代，从列表中的相应位置重新设置每个元素。 这样可以避免尝试将链表排序到目前为止的n 2 log（n）性能。
T - 列表中对象的类
list - 要排序的列表。
ClassCastException - 如果列表包含不
相互比较的元素 （例如，字符串和整数）。
UnsupportedOperationException - 如果指定列表的list-iterator不支持
set操作。
IllegalArgumentException - （可选）如果实现检测到发现列表元素的自然排序违反了Comparable合同
public static <T> void sort(List<T> list, Comparator<? super T> c)
c.compare(e1, e2)不能为ClassCastException中的任何元素e1和e2 ）。
这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。
指定的列表必须是可修改的，但不能调整大小。
实现注意事项：这个实现是一个稳定的，自适应的，迭代的mergeesort，当输入数组被部分排序时，需要比n lg（n）的比较少得多，同时在输入数组被随机排列时提供传统的mergeesort的性能。 如果输入数组几乎被排序，则实现需要大致n个比较。 临时存储要求从几乎排序的输入数组的小常数到随机排序的输入数组的n / 2对象引用。
该实现在其输入数组中具有上升和下降的同等优势，并且可以在同一输入数组的不同部分中利用升序和降序。 它非常适合合并两个或多个排序的数组：简单地连接数组并排序生成的数组。
该实现从Tim Peters的Python列表（ TimSort ）进行了改编 。 它使用Peter McIlroy的“乐观排序和信息理论复杂性”中的技术，在第四届ACM-SIAM离散算法研讨会论文集，pp 467-474，1993年1月。
该实现将指定的列表转储到数组中，对数组进行排序，并在列表中迭代，从列表中的相应位置重新设置每个元素。 这样可以避免尝试将链表排序到目前为止的n 2 log（n）性能。
T - 列表中对象的类
list - 要排序的列表。
c - 比较器来确定列表的顺序。
一个null值表示元素的自然排序应该被使用。
ClassCastException - 如果列表包含使用指定的比较器不
相互比较的元素。
UnsupportedOperationException - 如果指定的列表的list-iterator不支持
set操作。
IllegalArgumentException - （可选）如果比较方发现违反Comparator合同
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 - 要搜索的关键。
ClassCastException - 如果列表包含不
相互比较的元素 （例如，字符串和整数），或者搜索关键字与列表的元素不能相互比较。
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 - 排序列表的比较器。
A null值表示应使用元素' natural ordering '。
ClassCastException -如果列表中包含使用指定的比较器不可
相互比较的元素，或者检索关键字是不使用此比较的列表的元素相互比较。
public static void reverse(List<?> list)
该方法运行在线性时间。
list - 要反转其元素的列表。
UnsupportedOperationException - 如果指定的列表或其列表迭代器不支持
set操作。
public static void shuffle(List<?> list)
在前面的描述中使用了“大约”对冲，因为默认的随机源仅仅是独立选择的比特的无偏差源。 如果它是随机选择位的完美来源，则算法将选择具有完美均匀性的排列。
该实现从最后一个元素向后移动列表，重复地将随机选择的元素交换到“当前位置”中。 从从第一个元素运行到当前位置（包括）的列表的部分中随机选择元素。
该方法运行在线性时间。 如果指定的列表没有实现RandomAccess接口并且很大，则此实现将混合之前将指定的列表转储到数组中，并将该混洗的数组转储回列表中。 这避免了将“顺序访问”列表进行混洗所产生的二次行为。
list - 要洗牌的列表。
UnsupportedOperationException - 如果指定的列表或其列表迭代器不支持
set操作。
public static void shuffle(List<?> list, Random rnd)
该实现从最后一个元素向后移动列表，重复地将随机选择的元素交换到“当前位置”中。 从从第一个元素运行到当前位置（包括）的列表的部分中随机选择元素。
该方法运行在线性时间。 如果指定的列表没有实现RandomAccess接口，并且很大，那么这个实现会将指定的列表转储到数组中，然后再进行混洗，然后将该混洗后的数组转储回列表中。 这避免了将“顺序访问”列表进行混洗所产生的二次行为。
list - 要洗牌的列表。
rnd - 用于随机播放列表的随机源。
UnsupportedOperationException - 如果指定的列表或其列表迭代器不支持
set操作。
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（））。
public static <T> void fill(List<? super T> list, T obj)
该方法运行在线性时间。
T - 列表中对象的类
list - 要填充指定元素的列表。
obj - 用于填充指定列表的元素。
UnsupportedOperationException - 如果指定的列表或其列表迭代器不支持
set操作。
public static <T> void copy(List<? super T> dest, List<? extends T> src)
该方法运行在线性时间。
T - 列表中对象的类
dest - 目的地列表。
src - 源列表。
IndexOutOfBoundsException - 如果目的地列表太小，不能包含整个源列表。
UnsupportedOperationException - 如果目标列表的list-iterator不支持
set操作。
public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
该方法遍历整个集合，因此它需要与集合的大小成比例的时间。
T - 集合中对象的类
coll - 要确定其最小元素的集合。
ClassCastException - 如果集合包含不
相互比较的元素 （例如字符串和整数）。
NoSuchElementException - 如果集合为空。
Comparable
public static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
该方法遍历整个集合，因此它需要与集合的大小成比例的时间。
T - 集合中对象的类
coll - 要确定其最小元素的集合。
comp - 用于确定最小元素的比较器。
甲null值表示元素的自然顺序应该被使用。
ClassCastException - 如果集合包含使用指定比较器不
相互比较的元素。
NoSuchElementException - 如果集合为空。
Comparable
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
该方法遍历整个集合，因此它需要与集合的大小成比例的时间。
T - 集合中对象的类
coll - 要确定其最大元素的集合。
ClassCastException - 如果集合包含不
相互比较的元素 （例如，字符串和整数）。
NoSuchElementException - 如果集合为空。
Comparable
public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
该方法遍历整个集合，因此它需要与集合的大小成比例的时间。
T - 集合中对象的类
coll - 要确定其最大元素的集合。
comp - 用于确定最大元素的比较器。
一个null值表示应该使用元素的自然排序 。
ClassCastException - 如果集合包含使用指定的比较器不
相互比较的元素。
NoSuchElementException - 如果集合为空。
Comparable
public static void rotate(List<?> list, int distance)
例如，假设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操作。
public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
T - 列表中对象的类
list - 要
list的列表。
oldVal - 要替换的旧值。
newVal - 要替换
oldVal的新值。
UnsupportedOperationException - 如果指定的列表或其列表迭代器不支持
set操作。
public static int indexOfSubList(List<?> source, List<?> target)
source.subList(i, i+target.size()).equals(target) ，或-1如果没有这样的索引。
（如果target.size() > source.size()则返回-1）
该实现使用扫描源列表的“强力”技术，依次寻找与目标的匹配。
source - 搜索第一次发生的
列表target 。
target -列表搜索为
source子列表。
public static int lastIndexOfSubList(List<?> source, List<?> target)
source.subList(i, i+target.size()).equals(target) ，或-1如果没有这样的索引。
（如果target.size() > source.size()返回-1）
该实现使用在源列表上迭代的“强力”技术，依次查找每个位置上的目标匹配。
source - 搜索最后一次发生的
列表target 。
target -列表搜索为
source子列表。
public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c)
返回的集合不会通过hashCode并将操作等同于后台集合，而是依赖于Object的equals和hashCode方法。 在后台集合是集合或列表的情况下，必须保留这些操作的合同。
如果指定的集合是可序列化的，则返回的集合将是可序列化的。
T - 集合中对象的类
c - 要返回不可修改的视图的集合。
public static <T> Set<T> unmodifiableSet(Set<? extends T> s)
如果指定的集合是可序列化的，则返回的集合将是可序列化的。
T - 集合中对象的类
s - 要为其返回不可修改的视图的集合。
public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)
如果指定的排序集是可序列化的，则返回的排序集将是可序列化的。
T - 集合中对象的类
s - 要为其返回不可修改视图的排序集。
public static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s)
subSet ， headSet ，或tailSet意见，导致UnsupportedOperationException 。
如果指定的导航集是可序列化的，返回的导航集将是可序列化的。
T - 集合中对象的类
s - 要返回不可修改的视图的导航集
public static <T> List<T> unmodifiableList(List<? extends T> list)
如果指定的列表是可序列化的，则返回的列表将是可序列化的。 类似地，如果指定的列表，返回的列表将实现RandomAccess 。
T - 列表中对象的类
list - 要返回不可修改视图的列表。
public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m)
如果指定的地图是可序列化的，返回的地图将是可序列化的。
K - 地图键的类
V - 地图值的类
m - 要返回不可修改视图的地图。
public static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m)
如果指定的排序映射是可序列化的，返回的排序映射将是可序列化的。
K - 地图键的类
V - 地图值的类
m - 要返回不可修改视图的排序映射。
public static <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K,? extends V> m)
subMap ， headMap ，或tailMap意见，导致UnsupportedOperationException 。
如果指定的可导航地图是可序列化的，返回的导航地图将是可序列化的。
K - 地图键的类
V - 地图值的类
m - 要返回不可修改视图的导航地图
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方法。 在后台集合是集合或列表的情况下，必须保留这些操作的合同。
如果指定的集合是可序列化的，则返回的集合将是可序列化的。
T - 集合中对象的类
c - 要在同步集合中“包装”的集合。
public static <T> Set<T> synchronizedSet(Set<T> s)
用户在迭代过程中手动同步返回的集合是必不可少的：
Set s = Collections.synchronizedSet(new HashSet());
...
synchronized (s) {
Iterator i = s.iterator(); // Must be in the synchronized block
while (i.hasNext())
foo(i.next());
}
不遵循此建议可能会导致非确定性行为。
如果指定的集合是可序列化的，则返回的集合将是可序列化的。
T - 集合中对象的类
s - 要在同步集中“包装”的集合。
public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)
至关重要的是，用户迭代，或任何其subSet，headSet，或tailSet意见时，在返回的有序集合手动同步。
SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
...
synchronized (s) {
Iterator i = s.iterator(); // Must be in the synchronized block
while (i.hasNext())
foo(i.next());
}
要么：
SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
SortedSet s2 = s.headSet(foo);
...
synchronized (s) { // Note: s, not s2!!!
Iterator i = s2.iterator(); // Must be in the synchronized block
while (i.hasNext())
foo(i.next());
}
不遵循此建议可能会导致非确定性行为。
如果指定的排序集是可序列化的，则返回的排序集将是可序列化的。
T - 集合中对象的类
s - 排序集合在同步排序集中被“包装”。
public static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s)
当务之急是用户遍历其或其任何时候对返回导航set手动同步subSet ， headSet ，或tailSet意见。
NavigableSet s = Collections.synchronizedNavigableSet(new TreeSet());
...
synchronized (s) {
Iterator i = s.iterator(); // Must be in the synchronized block
while (i.hasNext())
foo(i.next());
}
要么：
NavigableSet s = Collections.synchronizedNavigableSet(new TreeSet());
NavigableSet s2 = s.headSet(foo, true);
...
synchronized (s) { // Note: s, not s2!!!
Iterator i = s2.iterator(); // Must be in the synchronized block
while (i.hasNext())
foo(i.next());
}
不遵循此建议可能会导致非确定性行为。
如果指定的导航集是可序列化的，返回的导航集将是可序列化的。
T - 集合中对象的类
s - 可导航组在同步导航集中被“包装”
public static <T> List<T> synchronizedList(List<T> list)
在迭代时，用户必须在返回的列表上手动同步：
List list = Collections.synchronizedList(new ArrayList());
...
synchronized (list) {
Iterator i = list.iterator(); // Must be in synchronized block
while (i.hasNext())
foo(i.next());
}
不遵循此建议可能会导致非确定性行为。
如果指定的列表是可序列化的，则返回的列表将是可序列化的。
T - 列表中对象的类
list - 要在同步列表中“包装”的列表。
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
在迭代其任何集合视图时，用户必须在返回的映射上手动同步：
Map m = Collections.synchronizedMap(new HashMap());
...
Set s = m.keySet(); // Needn't be in synchronized block
...
synchronized (m) { // Synchronizing on m, not s!
Iterator i = s.iterator(); // Must be in synchronized block
while (i.hasNext())
foo(i.next());
}
不遵循此建议可能会导致非确定性行为。
如果指定的地图是可序列化的，返回的地图将是可序列化的。
K - 地图键的类
V - 地图值的类
m - 要在同步地图中“包裹”的地图。
public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
至关重要的是，用户迭代它的任何collection视图，或任何其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());
}
不遵循此建议可能会导致非确定性行为。
如果指定的排序映射是可序列化的，返回的排序映射将是可序列化的。
K - 地图键的类
V - 地图值的类
m - 要在同步排序的映射中“包装”的排序映射。
public static <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m)
至关重要的是，用户迭代它的任何collection视图，或任何其集合视图时返回的导航地图上手动同步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());
}
不遵循此建议可能会导致非确定性行为。
如果指定的可导航地图是可序列化的，返回的导航地图将是可序列化的。
K - 地图键的类
V - 地图值的类
m - 可导航地图在同步导航地图中被“包裹”
public static <E> Collection<E> checkedCollection(Collection<E> c, 类<E> type)
ClassCastException 。
假设集合在生成动态类型安全视图之前不包含不正确类型的元素，并且通过视图发生对集合的所有后续访问，则可以确保集合不能包含不正确类型的元素。
该语言中的泛型机制提供了编译时（静态）类型检查，但是可以用未经检查的转换来击败此机制。 通常这不是问题，因为编译器在所有这些未经检查的操作上发出警告。 然而，有一次静态类型检查是不够的。 例如，假设集合被传递给第三方库，并且库代码不会通过插入错误类型的元素来破坏集合。
动态类型安全视图的另一个用途是调试。 假设一个程序失败，一个ClassCastException ，表示一个不正确的类型的元素被放入一个参数化的集合。 不幸的是，异常可以在插入错误元素之后的任何时间发生，因此它通常提供很少或没有关于问题的真正来源的信息。 如果问题是可重复的，可以通过临时修改程序来快速确定其来源，以便使用动态类型安全视图来包装该集合。 例如，这个声明：
Collection<String> c = new HashSet<>();
可以暂时用这个替换：
Collection<String> c = Collections.checkedCollection( new HashSet<>(), String.class);
再次运行该程序将导致它在将不正确类型的元素插入到集合中的位置失败，并清楚地标识出问题的根源。
一旦问题得到解决，修改的声明可能会恢复原来的。
返回的集合不将hashCode并传递给底层集合等于操作，而是依赖于Object的equals种hashCode方法。 在后台集合是集合或列表的情况下，必须保留这些操作的合同。
如果指定的集合是可序列化的，则返回的集合将是可序列化的。
由于null被认为是任何引用类型的值，所以返回的集合允许在后端集合执行时插入空元素。
E - 集合中对象的类
c - 要为其返回动态类型安全视图的集合
type -该元素的类型
c被允许保持
public static <E> Queue<E> checkedQueue(Queue<E> queue, 类<E> type)
ClassCastException 。
假设一个队列不包含任何类型不正确的生成动态类型安全视图的时间之前的元件，并且该队列的所有后续访问通过该视图发生时，它保证了队列不能包含类型不正确的元素。
关于使用动态类型安全视图的讨论可以在checkedCollection方法的文档中找到。
如果指定的队列是可序列化的，则返回的队列将是可序列化的。
由于null被认为是任何引用类型的值，返回的队列允许在支持队列执行时null元素。
E - 队列中对象的类
queue - 要为其返回动态类型安全视图的队列
type - 允许保持
queue的元素的类型
public static <E> Set<E> checkedSet(Set<E> s, 类<E> type)
ClassCastException 。
假设一组不包含任何类型不正确的生成动态类型安全视图的时间之前的元件，并且该组的所有后续访问通过该视图发生时，它保证了集不能包含类型不正确的元素。
关于使用动态类型安全视图的讨论可以在checkedCollection方法的文档中找到。
如果指定的集合是可序列化的，则返回的集合将是可序列化的。
由于null被认为是任何引用类型的值，所以返回的集合允许在后台集合中插入空元素。
E - 集合中对象的类
s - 要为其返回动态类型安全视图的集合
type -该元素的类型
s被允许保持
public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, 类<E> type)
ClassCastException 。
假设一个有序集合不包含任何错误键入之前生成动态类型安全视图时的元件，并且，为有序集合的所有后续访问通过该视图发生时，可以保证有序集合不能包含类型不正确的元素。
关于使用动态类型安全视图的讨论可以在checkedCollection方法的文档中找到。
如果指定的排序集是可序列化的，则返回的排序集将是可序列化的。
由于null被认为是任何引用类型的值，所以返回的排序集允许在后台排序集合时插入空元素。
E - 集合中对象的类
s - 要为其返回动态类型安全视图的排序集
type -该元素的类型
s被允许保持
public static <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s, 类<E> type)
ClassCastException 。
假设可导航集在生成动态类型安全视图之前不包含不正确类型的元素，并且通过视图进行对导航集的所有后续访问，则可以确保导航集不能包含不正确类型的元素。
关于使用动态类型安全视图的讨论可以在checkedCollection方法的文档中找到。
如果指定的导航集是可序列化的，返回的导航集将是可序列化的。
由于null被认为是任何引用类型的值，所以返回的导航集允许在后台排序集合时插入空元素。
E - 集合中对象的类
s - 要为其返回动态类型安全视图的导航集
type -该元素的类型
s被允许保持
public static <E> List<E> checkedList(List<E> list, 类<E> type)
ClassCastException 。
假设一个列表不包含错误键入的生成动态类型安全视图的时间之前的元件，并且其到列表中的所有后续访问通过该视图发生时，它保证了列表不能包含类型不正确的元素。
关于使用动态类型安全视图的讨论可以在checkedCollection方法的文档中找到。
如果指定的列表是可序列化的，则返回的列表将是可序列化的。
由于null被认为是任何引用类型的值，所以返回的列表允许在支持列表中插入空元素。
E - 列表中对象的类
list - 要为其返回动态类型安全视图的列表
type -该元素的类型
list被允许保持
public static <K,V> Map<K,V> checkedMap(Map<K,V> m, 类<K> keyType, 类<V> valueType)
ClassCastException 。
类似地，任何修改当前与密钥相关联的值的尝试将立即导致ClassCastException ，无论是通过地图本身直接尝试修改，还是通过从地图的entry set视图获取的Map.Entry实例。
假设映射不包含不正确时，所产生的动态类型安全视图的时间之前为键入的键或值，并且其相对于地图的所有后续访问通过该视图发生（或它的集合视图之一），它保证了地图不能包含错误键入的键或值。
关于使用动态类型安全视图的讨论可以在checkedCollection方法的文档中找到。
如果指定的地图是可序列化的，返回的地图将是可序列化的。
由于null被认为是任何引用类型的值，所以返回的映射允许每当支持地图执行时插入空值或值。
K - 地图键的类
V - 地图值的类
m - 要为其返回动态类型安全视图的地图
keyType -
m被允许保存的密钥的类型
valueType - 允许持有的
m的值的类型
public static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m, 类<K> keyType, 类<V> valueType)
ClassCastException 。
类似地，任何修改当前与密钥相关联的值的尝试将立即导致ClassCastException ，无论是通过地图本身直接尝试修改，还是通过从地图的entry set视图获取的Map.Entry实例。
假设映射不包含不正确时，所产生的动态类型安全视图的时间之前为键入的键或值，并且其相对于地图的所有后续访问通过该视图发生（或它的集合视图之一），它保证了地图不能包含错误键入的键或值。
关于使用动态类型安全视图的讨论可以在checkedCollection方法的文档中找到。
如果指定的地图是可序列化的，返回的地图将是可序列化的。
由于null被认为是任何引用类型的值，所以返回的映射允许每当支持地图执行时插入空值或值。
K - 地图键的类
V - 地图值的类
m - 要为其返回动态类型安全视图的地图
keyType -
m被允许持有的密钥的类型
valueType -即值的类型
m被允许保持
public static <K,V> NavigableMap<K,V> checkedNavigableMap(NavigableMap<K,V> m, 类<K> keyType, 类<V> valueType)
ClassCastException 。
类似地，任何修改当前与密钥相关联的值的尝试将立即导致ClassCastException ，无论是通过地图本身直接尝试修改，还是通过从地图的entry set视图获取的Map.Entry实例。
假设映射不包含不正确时，所产生的动态类型安全视图的时间之前为键入的键或值，并且其相对于地图的所有后续访问通过该视图发生（或它的集合视图之一），它保证了地图不能包含错误键入的键或值。
关于使用动态类型安全视图的讨论可以在checkedCollection方法的文档中找到。
如果指定的地图是可序列化的，返回的地图将是可序列化的。
由于null被认为是任何引用类型的值，所以返回的映射允许每当支持地图执行时插入空值或值。
K - 地图键的类型
V - 地图值的类型
m - 要为其返回动态类型安全视图的地图
keyType -
m被允许持有的密钥的类型
valueType - 允许持有的值为
m的值的类型
public static <T> Iterator<T> emptyIterator()
hasNext总是返回false 。 next总是抛出NoSuchElementException 。 remove总是抛出IllegalStateException 。 允许这种方法的实现，但不是必需的，从多个调用返回相同的对象。
T - 迭代器中元素的类型，如果有的话
public static <T> ListIterator<T> emptyListIterator()
hasNext和hasPrevious总是返回false 。 next和previous总是抛出NoSuchElementException 。 remove和set总是抛出IllegalStateException 。 add总是抛出UnsupportedOperationException 。 nextIndex总是返回0 。 previousIndex总是返回-1 。 允许这种方法的实现，但不是必需的，从多个调用返回相同的对象。
T - 迭代器中元素的类型，如果有的话
public static <T> Enumeration<T> emptyEnumeration()
hasMoreElements总是返回false 。 nextElement总是抛出NoSuchElementException 。 允许这种方法的实现，但不是必需的，从多个调用返回相同的对象。
T -
T中对象的类
public static final <T> Set<T> emptySet()
此示例说明了获取空集合的类型安全方式：
Set<String> s = Collections.emptySet();
Set对象。
使用此方法可能具有与使用相似名称的字段相当的成本。
（与此方法不同，该字段不提供类型安全性。）
T - 集合中的对象的类
EMPTY_SET
public static <E> SortedSet<E> emptySortedSet()
此示例说明了获取空排序集的类型安全方式：
SortedSet<String> s = Collections.emptySortedSet();
SortedSet对象。
E - 元素的类型，如果有的话，在集合中
public static <E> NavigableSet<E> emptyNavigableSet()
此示例说明了获取空导航集的类型安全方式：
NavigableSet<String> s = Collections.emptyNavigableSet();
NavigableSet对象。
E - 元素的类型，如果有的话，在集合中
public static final <T> List<T> emptyList()
此示例说明了获取空列表的类型安全方式：
List<String> s = Collections.emptyList();
实现说明：该方法的实现不需要为每个调用创建一个单独的List对象。
使用此方法可能具有与使用相似名称的字段相当的成本。
（与此方法不同，该字段不提供类型安全性。）
T - 列表中的元素类型，如果有的话
EMPTY_LIST
public static final <K,V> Map<K,V> emptyMap()
此示例说明了获取空地图的类型安全方式：
Map<String, Date> s = Collections.emptyMap();
Map对象。
使用此方法可能具有与使用相似名称的字段相当的成本。
（与此方法不同，该字段不提供类型安全性。）
K - 地图键的类
V - 地图值的类
EMPTY_MAP
public static final <K,V> SortedMap<K,V> emptySortedMap()
此示例说明了获取空地图的类型安全方式：
SortedMap<String, Date> s = Collections.emptySortedMap();
SortedMap对象。
K - 地图键的类
V - 地图值的类
public static final <K,V> NavigableMap<K,V> emptyNavigableMap()
此示例说明了获取空地图的类型安全方式：
NavigableMap<String, Date> s = Collections.emptyNavigableMap();
NavigableMap对象。
K - 地图键的类
V - 地图值的类
public static <T> Set<T> singleton(T o)
T - 集合中对象的类
o - 要存储在返回集合中的唯一对象。
public static <T> List<T> singletonList(T o)
T - 列表中对象的类
o - 要存储在返回列表中的唯一对象。
public static <K,V> Map<K,V> singletonMap(K key, V value)
K - 地图键的类
V - 地图值的类
key - 存储在返回地图中的唯一键。
value - 返回地图映射到的值
key 。
public static <T> List<T> nCopies(int n, T o)
T - 要复制的对象的类和返回列表中的对象的类。
n - 返回列表中的元素数。
o - 在返回的列表中重复出现的元素。
IllegalArgumentException - 如果
n < 0
List.addAll(Collection) ，
List.addAll(int, Collection)
public static <T> Comparator<T> reverseOrder()
Comparable接口的对象集合施加与自然排序相反的比较。
（自然顺序是由物体本身的确定的顺序对compareTo方法）。这使得能够简单成语用于分拣（或维持）实现该对象的集合（或阵列） Comparable在反向自然顺序接口。
例如，假设a是字符串数组。
然后：
Arrays.sort(a, Collections.reverseOrder());
以反字典（字母顺序）排列阵列。
返回的比较器是可序列化的。
T - 比较对象比较对象的类
Comparable
public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
null ，则该方法相当于reverseOrder() （换句话说，它返回一个比较器，它对实现Comparable接口的对象集合施加了自然排序的相反）。
返回的比较器是可串行化的（假设指定的比较器也可串行化或者null ）。
T - 比较类比较对象的类
cmp - 比较者的排序将由返回的比较器或
null
public static <T> Enumeration<T> enumeration(Collection<T> c)
T - 集合中对象的类
c - 要返回枚举的集合。
Enumeration
public static <T> ArrayList<T> list(Enumeration<T> e)
T -
T返回的对象的类
e - 枚举为返回的数组列表提供元素
Enumeration ， ArrayList
public static int frequency(Collection<?> c, Object o)
c - 其中确定o的频率的
集合
o - 要确定其频率的对象
c中元素的
c等于
o
NullPointerException - 如果
c为空
public static boolean disjoint(Collection<?> c1, Collection<?> c2)
true 。
如果这种方法用于不符合Collection的一般合同的Collection 。 实施方案可以选择在任一集合中迭代并测试另一集合中的包含（或执行任何等效计算）。 如果任何一个收集使用非标准平等的测试（如做了SortedSet ，其顺序是不是等号 ，或者按键的兼容 IdentityHashMap ），两个集合必须使用相同的非标准相等测试，或者这种方法的结果是不确定的。
当使用对它们可能包含的元素有限制的集合时，还必须小心。 允许集合实现为涉及其认为不合格的元素的任何操作抛出异常。 为了绝对安全，指定的集合只应包含两个集合的符合条件的元素。
请注意，允许在两个参数中传递相同的集合，在这种情况下，当且仅当集合为空时，该方法将返回true 。
c1 - 一个集合
c2 - 一个集合
true如果两个指定的集合没有共同的元素。
NullPointerException - 如果任一集合是
null 。
NullPointerException - 如果一个集合包含一个null元素，并且null不是其他集合的合格元素。
（ optional ）
ClassCastException - 如果一个集合包含一个不符合其他集合类型的元素。
（ optional ）
@SafeVarargs public static <T> boolean addAll(Collection<? super T> c, T... elements)
单独指定元素时，此方法为现有集合添加一些元素提供了一种便捷的方法：
Collections.addAll(flavors, "Peaches 'n Plutonium", "Rocky Racoon");
T - 要添加和收集的元素的类
c - 要插入
elements的集合
elements - 要插入到
c的元素
UnsupportedOperationException - 如果
c不支持
add操作
NullPointerException - 如果
elements包含一个或多个空值，并且
c不允许空元素，或者如果
c或
elements为
null
IllegalArgumentException -如果在
elements一个值的某些属性不允许它添加到
c
Collection.addAll(Collection)
public static <E> Set<E> newSetFromMap(Map<E,Boolean> map)
Set对应于任何执行Map实现。
已经有Set实现（例如HashMap或TreeMap ）的Map实现没有必要使用此方法。
在该方法返回的集合上的每个方法调用都会在后台映射或其keySet视图上完成一个方法调用，但有一个例外。 addAll方法在辅助地图上以put调用的顺序实现。
在调用此方法时，指定的映射必须为空，并且在此方法返回后不能直接访问。 如果映射创建为空，直接传递给此方法，并且不保留对映射的引用，则保证这些条件，如以下代码片段所示：
Set<Object> weakHashSet = Collections.newSetFromMap(
new WeakHashMap<Object, Boolean>());
E - 映射键和返回集中的对象的类
map - 支持地图
IllegalArgumentException - 如果
map不为空
public static <T> Queue<T> asLifoQueue(Deque<T> deque)
Deque作为先进先出（ Lifo ） Queue的视图 。
方法add被映射到push，remove映射到pop等。
当您想使用需要Queue但需要Lifo订购的方法时，此视图可能很有用。
通过此方法返回的队列上的每个方法调用都将在支持deque上完成一个方法调用，但有一个例外。 addAll方法被实现为一个addFirst对支持deque的调用的序列。
T - 在deque中的对象的类
deque - deque
Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.