Module java.base

软件包 java.util

Class Collections

java.lang.Object

java.util.Collections

public class Collections
extends Object

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

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

包含在这个类中的多态算法的文档通常包括执行情况的简短描述。 这些描述应被视为实施说明 ，而不是说明书的一部分 。 只要规范本身得到遵守，实现者就可以随意替代其他算法。 （例如， sort使用的算法不一定是一个mergeesort，但它必须是稳定的 。）

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

这个班是Java Collections Framework的会员。

从以下版本开始：

1.2

另请参见：

Collection ， Set ， List ， Map

Field Summary

Fields

Modifier and Type	Field	描述
static List	EMPTY_LIST	空列表（不可变）。
static Map	EMPTY_MAP	空地图（immutable）。
static Set	EMPTY_SET	空集（不可变）。

方法摘要

Modifier and Type	方法	描述
static <T> boolean	addAll(Collection<? super T> c, T... elements)	将所有指定的元素添加到指定的集合。
static <T> Queue<T>	asLifoQueue(Deque<T> deque)	返回Deque作为先进先出（ Lifo ） Queue的视图 。
static <T> int	binarySearch(List<? extends Comparable<? super T>> list, T key)	使用二叉搜索算法搜索指定对象的指定列表。
static <T> int	binarySearch(List<? extends T> list, T key, Comparator<? super T> c)	使用二叉搜索算法搜索指定对象的指定列表。
static <E> Collection<E>	checkedCollection(Collection<E> c, Class<E> type)	返回指定集合的动态类型安全视图。
static <E> List<E>	checkedList(List<E> list, Class<E> type)	返回指定列表的动态类型安全视图。
static <K,V> Map<K,V>	checkedMap(Map<K,V> m, Class<K> keyType, Class<V> valueType)	返回指定地图的动态类型安全视图。
static <K,V> NavigableMap<K,V>	checkedNavigableMap(NavigableMap<K,V> m, Class<K> keyType, Class<V> valueType)	返回指定可导航地图的动态类型安全视图。
static <E> NavigableSet<E>	checkedNavigableSet(NavigableSet<E> s, Class<E> type)	返回指定的可导航集的动态类型安全视图。
static <E> Queue<E>	checkedQueue(Queue<E> queue, Class<E> type)	返回指定队列的动态类型安全视图。
static <E> Set<E>	checkedSet(Set<E> s, Class<E> type)	返回指定集合的动态类型安全视图。
static <K,V> SortedMap<K,V>	checkedSortedMap(SortedMap<K,V> m, Class<K> keyType, Class<V> valueType)	返回指定排序映射的动态类型安全视图。
static <E> SortedSet<E>	checkedSortedSet(SortedSet<E> s, Class<E> type)	返回指定排序集的动态类型安全视图。
static <T> void	copy(List<? super T> dest, List<? extends T> src)	将所有元素从一个列表复制到另一个列表中。
static boolean	disjoint(Collection<?> c1, Collection<?> c2)	如果两个指定的集合没有共同的元素，则返回 true 。
static <T> Enumeration<T>	emptyEnumeration()	返回没有元素的枚举。
static <T> Iterator<T>	emptyIterator()	返回没有元素的迭代器。
static <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>> 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)	返回由指定地图支持的集合。
static <T> boolean	replaceAll(List<T> list, T oldVal, T newVal)	将列表中一个指定值的所有出现替换为另一个。
static void	reverse(List<?> list)	反转指定列表中元素的顺序。
static <T> Comparator<T>	reverseOrder()	返回一个比较器， Comparable实现 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>> void	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)	返回指定排序集的不可修改视图。

Methods inherited from class 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

空地图（immutable）。 这张地图是可序列化的。

从以下版本开始：

1.3

另请参见：

emptyMap()

方法详细信息

sort

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

根据其元素的natural ordering ，将指定的列表按升序排序。 列表中的所有元素必须实现Comparable界面。 此外，列表中的所有元素必须相互可比较 （即， e1.compareTo(e2)不能为ClassCastException中的任何元素e1和e2抛出ClassCastException ）。

这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。

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

Implementation Note:

该实现将使用指定的列表和 null比较器来 取代List.sort(Comparator)方法。

参数类型

T - 列表中对象的类

参数

list - 要排序的列表。

异常

ClassCastException - 如果列表包含不 相互比较的元素（例如，字符串和整数）。

UnsupportedOperationException - 如果指定的列表的list-iterator不支持 set操作。

IllegalArgumentException - （可选）如果实现检测到发现列表元素的自然排序违反了Comparable合同

另请参见：

List.sort(Comparator)

sort

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

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

这种保证是稳定的 ：等同的元素将不会被排序作为排序的结果。

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

Implementation Note:

此实现将使用指定的列表和比较器来执行 List.sort(Comparator)方法。

参数类型

T - 列表中对象的类

参数

list - 要排序的列表。

c - 比较器来确定列表的顺序。 值null表示元素的自然排序应该被使用。

异常

ClassCastException - 如果列表包含使用指定比较器不 相互比较的元素。

UnsupportedOperationException - 如果指定的列表的list-iterator不支持 set操作。

IllegalArgumentException - （可选）如果比较方发现违反Comparator合同

另请参见：

List.sort(Comparator)

binarySearch

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

使用二叉搜索算法搜索指定对象的指定列表。 该列表必须根据被按升序排列natural ordering元素（如由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 - 排序列表的比较器。 A null值表示应使用元素' natural ordering '。

结果

搜索键的索引，如果它包含在列表中; 否则， (-(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 - 如果目标列表的list-iterator不支持 set操作。

min

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

根据其元素的自然顺序返回给定集合的最小元素。 集合中的所有元素必须实现Comparable界面。 此外，集合中的所有元素必须相互可比较 （即， e1.compareTo(e2)不得为ClassCastException中的任何元素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)不得为ClassCastException中的任何元素e1和e2抛出ClassCastException ）。

该方法遍历整个集合，因此它需要与集合的大小成比例的时间。

参数类型

T - 集合中对象的类

参数

coll - 要确定其最小元素的集合。

comp - 用于确定最小元素的比较器。 A null值表示应该使用元素的自然排序 。

结果

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

异常

ClassCastException - 如果集合包含使用指定的比较器不 相互比较的元素。

NoSuchElementException - 如果集合为空。

另请参见：

Comparable

max

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

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

该方法遍历整个集合，因此它需要与集合的大小成比例的时间。

参数类型

T - 集合中对象的类

参数

coll - 要确定其最大元素的集合。

结果

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

异常

ClassCastException - 如果集合包含不 相互比较的元素（例如字符串和整数）。

NoSuchElementException - 如果集合为空。

另请参见：

Comparable

max

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

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

该方法遍历整个集合，因此它需要与集合的大小成比例的时间。

参数类型

T - 集合中对象的类

参数

coll - 要确定其最大元素的集合。

comp - 用于确定最大元素的比较器。 A null值表示应使用元素的自然排序 。

结果

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

异常

ClassCastException - 如果集合包含使用指定比较器不 相互比较的元素。

NoSuchElementException - 如果集合为空。

另请参见：

Comparable

rotate

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

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

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

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

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

为了使这个具体，假设list包括[a, b, c, d, e] 。 要将索引号为1 （ b ）的元素向前移动两个位置，请执行以下调用：

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

得到的列表是[a, c, d, b, e] 。

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

如果指定的列表较小或实现了RandomAccess接口，则该实现将第一个元素交换到应该进行的位置，然后重复地将移位的元素交换到应该进行的位置，直到将替换的元素交换到第一个元素中。 如果需要，在第二和连续元件上重复该过程，直到旋转完成。 如果指定的列表很大并且没有实现RandomAccess接口，则此实现会将列表分解为索引-distance mod size周围的两个子列表视图。 然后在每个子列表视图中调用reverse(List)方法，最后在整个列表中调用它。 有关这两种算法的更完整的描述，请参见Jon Bentley 编程珍珠的第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每个元素e在list这样(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，如果没有这样的指标。 （如果为target.size() > source.size()返回-1）

该实现使用扫描源列表的“强力”技术，依次寻找与目标的匹配。

参数

source - 搜索第一次出现的 target 。

target - 作为source的 source列表搜索的列表。

结果

在指定源列表中首次出现指定目标列表的起始位置，如果没有此类事件，则为-1。

从以下版本开始：

1.4

lastIndexOfSubList

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

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

该实现使用在源列表上迭代的“强力”技术，依次查找每个位置上的目标匹配。

参数

source - 搜索最近发生的 target 。

target - 搜索作为source的 source列表的列表。

结果

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

从以下版本开始：

1.4

unmodifiableCollection

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

返回指定集合的不可修改视图。 该方法允许模块向用户提供对内部集合的“只读”访问。 对返回的集合“读取”查询操作到指定的集合，并尝试修改返回的集合，无论是直接还是通过其迭代器生成一个UnsupportedOperationException 。

返回的集合不将hashCode并传递给底层集合等于操作，而是依赖于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)

返回指定的可导航集合的不可修改的视图。 该方法允许模块向用户提供对内部导航集的“只读”访问。 对返回的导航集“查阅”查询操作到指定的导航集。 试图修改返回的导航set，不管是直接的，通过其迭代器，或通过其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)

返回指定地图的不可修改视图。 该方法允许模块向用户提供对内部地图的“只读”访问。 将返回的地图上的查询操作“读取”到指定的地图，并尝试修改返回的地图，无论是直接的还是通过其集合视图，都会产生一个UnsupportedOperationException 。

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

参数类型

K - 地图键的类

V - 地图值的类

参数

m - 要返回不可修改视图的地图。

结果

指定地图的不可修改视图。

unmodifiableSortedMap

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

返回指定排序映射的不可修改视图。 该方法允许模块向用户提供对内部排序映射的“只读”访问。 对返回的排序映射查询操作“读取”到指定的排序映射。 试图修改返回的有序映射，无论是直接的，通过其收集的意见，或通过其subMap ， headMap ，或tailMap意见，导致UnsupportedOperationException 。

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

参数类型

K - 地图键的类

V - 地图值的类

参数

m - 要为其返回不可修改视图的排序映射。

结果

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

unmodifiableNavigableMap

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

返回指定可导航地图的不可修改视图。 这种方法允许模块向用户提供对内部可导航地图的“只读”访问。 在返回的导航地图上查询操作“通读”到指定的可导航地图。 试图修改返回的导航地图，无论是直接的，通过其收集的意见，或通过其subMap ， headMap ，或tailMap意见，导致UnsupportedOperationException 。

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

参数类型

K - 地图键的类

V - 地图值的类

参数

m - 要返回不可修改的视图的导航地图

结果

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

从以下版本开始：

1.8

synchronizedCollection

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

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

至关重要的是，用户通过遍历时，在返回的集合手动同步Iterator ， Spliterator或者Stream ：

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

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

返回的集合不通过hashCode个equals传递给底层收集操作，而是依赖于Object的equals和hashCode方法。 在后台集合是集合或列表的情况下，必须保留这些操作的合同。

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

参数类型

T - 集合中对象的类

参数

c - 要在同步集合中“包装”的集合。

结果

指定集合的同步视图。

synchronizedSet

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

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

至关重要的是，用户通过遍历时，在返回的集合手动同步Iterator ， Spliterator或者Stream ：

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

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

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

参数类型

T - 集合中对象的类

参数

s - 要在同步集中“包装”的集合。

结果

指定集合的同步视图。

synchronizedSortedSet

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

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

当务之急是用户遍历时，或任何其对返回的有序集合手动同步subSet ， headSet ，或tailSet通过意见Iterator ， Spliterator或者Stream ：

  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)

返回由指定的可导航集支持的同步（线程安全）可导航集。 为了保证串行访问，重要的是可以通过返回的可导航集（或其视图）来完成对后台导航集的所有访问。

至关重要的是，在用户遍历时对返回的导航set手动同步，或它的任何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)

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

至关重要的是，用户通过遍历时，它返回的列表上手动同步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)

返回由指定地图支持的同步（线程安全）映射。 为了保证串行访问，重要的是通过返回的映射完成对后台映射的所有访问。

至关重要的是，用户通过遍历它的任何集合视图时返回的地图上手动同步Iterator ， Spliterator或者Stream ：

  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 - 要在同步地图中“包裹”的地图。

结果

指定地图的同步视图。

synchronizedSortedMap

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

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

当务之急是用户遍历其任何收集意见，或任何其集合视图时返回的有序地图上手动同步subMap ， headMap或者tailMap意见，通过Iterator ， Spliterator或者Stream ：

  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 - 要在同步的排序映射中“包装”的排序映射。

结果

指定排序地图的同步视图。

synchronizedNavigableMap

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

返回由指定的可导航地图支持的同步（线程安全）可导航地图。 为了保证串行访问，重要的是可以通过返回的可导航地图（或其视图）来完成对后退导航地图的所有访问。

当务之急是用户遍历其任何收集意见，或任何其集合视图时返回的导航地图上手动同步subMap ， headMap或者tailMap意见，通过Iterator ， Spliterator或者Stream ：

  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 - 可导航地图在同步的可导航地图中被“包裹”

结果

指定可导航地图的同步视图。

从以下版本开始：

1.8

checkedCollection

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

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

该语言中的泛型机制提供了编译时（静态）类型检查，但是可以用未经检查的转换来击败此机制。 通常这不是问题，因为编译器在所有这些未经检查的操作上发出警告。 然而，有一次静态类型检查是不够的。 例如，假设集合被传递给第三方库，并且库代码不会通过插入错误类型的元素来破坏集合。

动态类型安全视图的另一个用途是调试。 假设一个程序失败，一个ClassCastException ，表示一个不正确的类型的元素被放入一个参数化的集合。 不幸的是，异常可以在插入错误元素之后的任何时间发生，因此它通常提供很少或没有关于问题的真正来源的信息。 如果问题是可重复的，可以通过临时修改程序来快速确定其来源，以便使用动态类型安全视图来包装该集合。 例如，这个声明：

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

可以暂时用这个替换：

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

再次运行该程序将导致它在将不正确类型的元素插入到集合中的位置失败，并清楚地标识出问题的根源。 一旦问题得到解决，修改的声明可能会恢复原来的。

返回的集合不将hashCode并传递给底层集合等于操作，而是依赖于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 。 假设可导航集在生成动态类型安全视图之前不包含不正确类型的元素，并且通过视图进行对导航集的所有后续访问，则可以确保导航集不能包含不正确类型的元素。

关于使用动态类型安全视图的讨论可以在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)

返回指定地图的动态类型安全视图。 任何尝试插入其键或值类型错误的映射将导致立即ClassCastException 。 类似地，任何尝试修改当前与密钥相关联的值将导致立即ClassCastException ，无论是直接通过地图本身进行修改，还是通过从地图的entry set视图获取的一个2706143419311实例。

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

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

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

由于null被认为是任何引用类型的值，返回的映射允许每当支持地图执行时插入空值或值。

参数类型

K - 地图键的类

V - 地图值的类

参数

m - 要为其返回动态类型安全视图的地图

keyType - m允许持有的密钥的类型

valueType - m允许持有的值的类型

结果

指定地图的动态类型安全视图

从以下版本开始：

1.5

checkedSortedMap

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

返回指定排序映射的动态类型安全视图。 任何尝试插入其键或值具有错误类型的映射将导致立即ClassCastException 。 类似地，任何修改当前与密钥相关联的值的尝试都将立即产生ClassCastException ，无论是通过地图本身直接尝试修改，还是通过从地图的entry set视图获取的一个2706143422977实例。

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

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

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

由于null被认为是任何引用类型的值，返回的映射允许每当支持地图执行时插入空值或值。

参数类型

K - 地图键的类

V - 地图值的类

参数

m - 要为其返回动态类型安全视图的地图

keyType - m允许的密钥类型

valueType - m允许持有的值的类型

结果

指定地图的动态类型安全视图

从以下版本开始：

1.5

checkedNavigableMap

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

返回指定可导航地图的动态类型安全视图。 任何尝试插入其键或值的类型错误的映射将导致立即ClassCastException 。 类似地，任何修改当前与密钥相关联的值的尝试将导致立即ClassCastException ，无论是通过地图本身直接尝试修改，还是通过从地图entry set视图获取的2706143433384实例。

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

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

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

由于null被认为是任何引用类型的值，所以返回的映射允许每当支持地图执行时插入空值或值。

参数类型

K - 地图键的类型

V - 地图值的类型

参数

m - 要为其返回动态类型安全视图的地图

keyType - m允许持有的密钥的类型

valueType - m允许持有的值的类型

结果

指定地图的动态类型安全视图

从以下版本开始：

1.8

emptyIterator

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

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

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

允许这种方法的实现，但不是必需的，从多个调用返回相同的对象。

参数类型

T - 迭代器中的元素类型，如果有的话

结果

一个空的迭代器

从以下版本开始：

1.7

emptyListIterator

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

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

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

允许这种方法的实现，但不是必需的，从多个调用返回相同的对象。

参数类型

T - 迭代器中的元素的类型，如果有的话

结果

一个空列表迭代器

从以下版本开始：

1.7

emptyEnumeration

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

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

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

允许这种方法的实现，但不是必需的，从多个调用返回相同的对象。

参数类型

T - 枚举中的对象的类

结果

一个空的枚举

从以下版本开始：

1.7

emptySet

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

返回一个空集（immutable）。 这个集是可序列化的。 与类似命名的字段不同，该方法被参数化。

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

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

Implementation Note:

该方法的实现不需要为每个调用创建一个单独的Set对象。 使用此方法可能具有与使用相似名称的字段相当的成本。 （与此方法不同，该字段不提供类型安全性。）

参数类型

T - 集合中对象的类

结果

空集

从以下版本开始：

1.5

另请参见：

EMPTY_SET

emptySortedSet

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

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

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

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

Implementation Note:

该方法的实现不需要为每个调用创建一个单独的 SortedSet对象。

参数类型

E - 元素的类型，如果有的话，在集合中

结果

空排序集

从以下版本开始：

1.8

emptyNavigableSet

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

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

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

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

Implementation Note:

该方法的实现不需要为每个调用创建一个单独的 NavigableSet对象。

参数类型

E - 元素的类型，如果有的话，在集合中

结果

空导航集

从以下版本开始：

1.8

emptyList

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

返回空列表（immutable）。 此列表是可序列化的。

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

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

Implementation Note:

该方法的实现不需要为每个调用创建一个单独的List对象。 使用此方法可能具有与使用相似名称的字段相当的成本。 （与此方法不同，该字段不提供类型安全性。）

参数类型

T - 列表中的元素类型，如果有的话

结果

一个空的不变名单

从以下版本开始：

1.5

另请参见：

EMPTY_LIST

emptyMap

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

返回空的地图（不可变）。 这张地图是可序列化的。

此示例说明了获取空地图的类型安全方式：

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

Implementation Note:

该方法的实现不需要为每个调用创建一个单独的Map对象。 使用此方法可能具有与使用相似名称的字段相当的成本。 （与此方法不同，该字段不提供类型安全性。）

参数类型

K - 地图键的类

V - 地图值的类

结果

一张空地图

从以下版本开始：

1.5

另请参见：

EMPTY_MAP

emptySortedMap

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

返回空的排序映射（immutable）。 这张地图是可序列化的。

此示例说明了获取空地图的类型安全方式：

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

Implementation Note:

该方法的实现不需要为每个调用创建一个单独的 SortedMap对象。

参数类型

K - 地图键的类

V - 地图值的类

结果

一个空的排序地图

从以下版本开始：

1.8

emptyNavigableMap

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

返回空导航地图（不可变）。 这张地图是可序列化的。

此示例说明了获取空地图的类型安全方式：

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

Implementation Note:

该方法的实现不需要为每个调用创建一个单独的 NavigableMap对象。

参数类型

K - 地图键的类

V - 地图值的类

结果

一个空的导航地图

从以下版本开始：

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)

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

参数类型

K - 地图键的类

V - 地图值的类

参数

key - 存储在返回地图中的唯一键。

value - 返回地图映射的值 key 。

结果

一个不可变的地图，只包含指定的键值映射。

从以下版本开始：

1.3

nCopies

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

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

参数类型

T - 要复制的对象的类和返回列表中的对象的类。

参数

n - 返回列表中的元素数。

o - 在返回的列表中重复出现的元素。

结果

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

异常

IllegalArgumentException - 如果是 n < 0

另请参见：

List.addAll(Collection) ， List.addAll(int, Collection)

reverseOrder

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

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

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

以反字典（字母顺序）排列阵列。

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

参数类型

T - 比较对象比较对象的类

结果

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

另请参见：

Comparable

reverseOrder

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

返回一个比较器，它强制指定比较器的反向排序。 如果指定的比较器是null ，则该方法相当于reverseOrder() （换句话说，它返回一个比较器，它对实现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)

返回指定集合中与指定对象相等的元素数。 更正式地，返回集合中的元素数量e ，使得Objects.equals(o, e) 。

参数

c - 其中确定频率的 o

o - 要确定频率的对象

结果

c中元素的 c等于 o

异常

NullPointerException - 如果 c为空

从以下版本开始：

1.5

disjoint

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 ）

从以下版本开始：

1.5

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

参数类型

T - 要添加和收集的元素的类

参数

c -到其中的收集 elements将被插入

elements - 要插入到 c的元素

结果

true如果集合由于调用而更改

异常

UnsupportedOperationException - 如果 c不支持 add操作

NullPointerException - 如果 elements包含一个或多个空值，并且 c不允许空元素，或者如果 c或 elements为 null

IllegalArgumentException - 如果某些属性在 elements中的值无法将其添加到 c

从以下版本开始：

1.5

另请参见：

Collection.addAll(Collection)

newSetFromMap

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

返回由指定地图支持的集合。 结果集显示与背景映射相同的排序，并发和性能特征。 在本质上，此工厂方法提供了一种Set对应于任何执行Map实现。 在已经具有相应的Set实现（例如HashMap或TreeMap ）的Map实现上，不需要使用此方法。

在该方法返回的集合上的每个方法调用将导致在后备映射或其keySet视图上的一个方法调用，但有一个例外。 addAll方法在支持地图上作为put调用的顺序实现。

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

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

参数类型

E - 映射关键字和返回集合中对象的类

参数

map - 支持地图

结果

该集合由地图支持

异常

IllegalArgumentException - 如果 map不为空

从以下版本开始：

1.6

asLifoQueue

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

返回Deque作为先进先出（ Lifo ） Queue的视图 。 方法add被映射到push ， remove映射到pop等。 当您想使用需要Queue的方法但您需要Queue订购时，此视图可能很有用。

通过此方法返回的队列上的每个方法调用都将在支持deque上完成一个方法调用，但有一个例外。 addAll方法作为支持deque的addFirst调用的序列实现。

参数类型

T - 在deque中的对象的类

参数

deque - deque

结果

队列

从以下版本开始：

1.6