compact1, compact2, compact3

java.util

Class Collections

java.lang.Object

java.util.Collections

public class Collections
extends Object

这个类只包含操作或返回集合的静态方法。它包含多态算法操作的集合，“包装”，它返回一个按指定的集合支持的新的集合，和其他一些零碎的东西。

这个类的方法把一NullPointerException如果集合或类对象提供的都是零。

对多态性算法中包含的文档这类一般包括一个简短的描述实施。这样的描述应该是实现注意事项，而不是部分的规范。实施者应随时替代其他算法，只要规范本身就是坚持。（例如，用sort算法不需要归并排序，但它必须稳定的。）

“破坏性”的算法包含在这个类，即算法，修改其操作集合，规定如果集合不支持相应的突变原始扔UnsupportedOperationException（S），如set方法。这些算法可以，但不需要，抛出这个异常，如果一个调用将不会对集合有影响。例如，调用sort方法在一个不可修改的列表，已经排序的可能或不可能把UnsupportedOperationException。

这个班的一员 Java Collections Framework。

从以下版本开始：

一点二

另请参见：

Collection， Set， List， Map

Field Summary

Fields

Modifier and Type	Field and Description
static List	EMPTY_LIST 空列表（不可变）。
static Map	EMPTY_MAP 空Map（不可变）。
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) 返回一个 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, 类<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) 返回一个动态类型安全的查看指定的Map。
static <K,V> NavigableMap<K,V>	checkedNavigableMap(NavigableMap<K,V> m, 类<K> keyType, 类<V> valueType) 返回一个动态类型安全的查看指定的导航电子Map。
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() 返回一个空列表（不可变）。
static <T> ListIterator<T>	emptyListIterator() 返回一个没有元素的列表迭代器。
static <K,V> Map<K,V>	emptyMap() 返回一个空Map（不可变）。
static <K,V> NavigableMap<K,V>	emptyNavigableMap() 返回一个空的导航Map（不可变）。
static <E> NavigableSet<E>	emptyNavigableSet() 返回一个空的导航集（不可变）。
static <T> Set<T>	emptySet() 返回一个空集（不可变）。
static <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) 返回一个由指定的映射支持的集合。
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) 返回一个不可改变的Map，只将指定的指定的键映射到指定的值。
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) 返回由指定的Map支持的同步（线程安全）Map。
static <K,V> NavigableMap<K,V>	synchronizedNavigableMap(NavigableMap<K,V> m) 返回指定的导航Map支持的同步（线程安全）导航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) 返回一个由指定的排序映射支持的同步（线程安全）排序的Map。
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) 返回指定的导航电子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) 返回指定的排序设置不可修改的视图。

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

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是可序列化。

从以下版本开始：

一点三

另请参见：

emptyMap()

方法详细信息

sort

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

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

这种保证是稳定的：相等的元素不会被重新排序结果的排序。

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

注：这是一个实现实现稳定、自适应迭代归并排序需要远少于n lg（n）比较，当输入阵列部分排序，同时提供传统的归并排序的性能时，输入数组的随机排列。如果输入数组几乎是排序的，实现需要约n个比较。临时存储的要求不同从一个小的常数为近排序的输入阵列到n / 2对象的参考随机排列的输入阵列。

在相同的输入数组中，实现在它的输入数组中具有相同的上升和下降的顺序，并可以利用在不同的部分的上升和下降的顺序。它非常适合于合并两个或多个已排序数组：直接连接阵列和由此产生的数组排序。

实施改编自Tim Peters的列表排序为Python（ TimSort）。它采用的技术，从Peter McIlroy的“乐观的排序和信息理论的复杂性”，在第四届研讨会上ANALCO ACM- SIAM离散算法，PP 467-474，一月1993。

这个实现转储到一个数组中指定的列表，排序的数组，遍历列表重置各要素从数组中的对应位置。这避免了n^二 log（n）的性能，将导致试图一个链表排序。

参数类型

T的对象列表中的类

参数

list -列表进行排序。

异常

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

UnsupportedOperationException -如果指定列表的列表迭代器不支持 set操作。

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

sort

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

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

这种保证是稳定的：相等的元素不会被重新排序结果的排序。

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

注：这是一个实现实现稳定、自适应迭代归并排序需要远少于n lg（n）比较，当输入阵列部分排序，同时提供传统的归并排序的性能时，输入数组的随机排列。如果输入数组几乎是排序的，实现需要约n个比较。临时存储的要求不同从一个小的常数为近排序的输入阵列到n / 2对象的参考随机排列的输入阵列。

在相同的输入数组中，实现在它的输入数组中具有相同的上升和下降的顺序，并可以利用在不同的部分的上升和下降的顺序。它非常适合于合并两个或多个已排序数组：直接连接阵列和由此产生的数组排序。

实施改编自Tim Peters的列表排序为Python（ TimSort）。它采用的技术，从Peter McIlroy的“乐观的排序和信息理论的复杂性”，在第四届研讨会上ANALCO ACM- SIAM离散算法，PP 467-474，一月1993。

这个实现转储到一个数组中指定的列表，排序的数组，遍历列表重置各要素从数组中的对应位置。这避免了n^二 log（n）的性能，将导致试图一个链表排序。

参数类型

T的对象列表中的类

参数

list -列表进行排序。

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

异常

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

UnsupportedOperationException -如果指定列表的列表迭代器不支持 set操作。

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

binarySearch

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

使用二进制搜索算法搜索指定对象的指定列表。列表必须排序为升序按其元素的 natural ordering（由 sort(List)法）进行调用之前。如果它没有排序，结果是不确定的。如果列表中包含多个元素等于指定的对象，则无法找到一个将被发现的保证。

这种方法运行在日志（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)方法），使这个打电话之前。如果它没有排序，结果是不确定的。如果列表中包含多个元素等于指定的对象，则无法找到一个将被发现的保证。

这种方法运行在日志（n）的时间为一个“随机访问”列表（它提供了接近恒定的时间位置访问）。如果指定的目录不实施RandomAccess接口和大，此方法将做一个基于迭代器的二进制搜索执行O（n）的链接遍历和O（log n）的元素比较。

参数类型

T的对象列表中的类

参数

list -列表搜索。

key -要搜索的关键。

c -比较器的列表是有序的。一个 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 | |我> =列表。size() | | J＜0 | | J > =列表。size()）。

从以下版本开始：

一点四

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)

按指定的距离旋转指定列表中的元素。调用此方法后，在指数 i元素将元以前在指数 (i - distance) MOD list.size()，为 0和 list.size()-1 i之间的所有值，包括。（此方法已在列表中。大小无影响）

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

请注意，此方法可以有效地应用到子表，将一个或多个元素在一个列表的同时保留剩余的元素的顺序。例如，下列成语动作元素在指数j前进到位置k（必须大于或等于j）：

收藏。旋转（列表。列表（J，K + 1），1）；

使混凝土，想 list包括 [a, b, c, d, e]。移动单元在指数 1（ b）提出了两个位置，执行下面的调用：

收藏。旋转（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操作。

从以下版本开始：

一点四

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包含一个或多个元素， (oldVal==null ? e==null : oldVal.equals(e)) e。

异常

UnsupportedOperationException -如果指定列表或列表迭代器不支持 set操作。

从以下版本开始：

一点四

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。

从以下版本开始：

一点四

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。

结果

在指定的源列表中指定目标列表的最后一个发生的起始位置，或-如果没有这样的发生。

从以下版本开始：

一点四

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)

返回指定通航设置不可修改的视图。这种方法允许模块为用户提供“只读”访问内部可导航集。返回的可导航集“读通过”到指定的可导航集的查询操作。试图修改恢复通航，无论是直接的，通过它的迭代器，或者通过 subSet， headSet，或 tailSet视图，在一个 UnsupportedOperationException结果。

返回的通航将如果指定通航设置序列化是可串行化。

参数类型

T的对象集合中的类

参数

s -设置为一个不可修改的视图导航要返回

结果

指定的设置不可修改的视图导航

从以下版本开始：

一点八

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是可序列化是可串行化。

结果。

参数类型

KMap的关键类

VMap的价值类

参数

m -Map上一个不可修改的观点是要归还。

结果

指定的Map一个不可修改的视图。

unmodifiableSortedMap

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

返回指定的排序图上一个不可修改的视图。这种方法允许模块为用户提供“只读”访问内部排序映射。将返回的排序映射“读通过”到指定的排序映射的查询操作。试图修改返回排序图上，无论是直接的，通过收集意见，或通过其 subMap， headMap，或 tailMap视图，在一个 UnsupportedOperationException结果。

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

参数类型

KMap的关键类

VMap的价值类

参数

m -排序的Map上一个不可修改的观点是要归还。

结果

指定的排序图上一个不可修改的视图。

unmodifiableNavigableMap

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

返回指定的导航电子Map的一个不可修改的视图。这种方法允许模块为用户提供“只读”访问内部可导航Map。将返回的导航Map“读通过”到指定的可导航Map的查询操作。尝试修改返回的导航Map，无论是直接的，通过收集意见，或通过其 subMap， headMap，或 tailMap视图，在一个 UnsupportedOperationException结果。

返回的导航电子Map将如果指定的导航电子Map是可序列化序列化。

参数类型

KMap的关键类

VMap的价值类

参数

m -导航电子Map的一个不可修改的观点是要归还

结果

指定的一个不可修改的视图导航电子Map

从以下版本开始：

一点八

synchronizedCollection

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

返回由指定集合支持的同步（线程安全）集合。为了保证串行访问，这是 全部的访问支持采集是通过返回的集合实现的关键。

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

收集C =集合。synchronizedcollection（我的）；…同步（c）迭代器我= C（）；//必须在同步块而（我hasnext()）foo（即next()）；}

未能遵循这个建议可能导致不确定的行为。

返回的集合是不通过hashCode和equals操作通过对支持收藏，但依靠Object的equals和hashCode方法。这是必要的，以保存这些操作的合同的情况下，备份集合是一个集合或列表。

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

参数类型

T的对象集合中的类

参数

c -集合是“包裹”在一个同步采集。

结果

指定集合的同步视图。

synchronizedSet

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

返回一个由指定集合支持的同步（线程安全）集。为了保证串行访问，这是 全部的访问的支持是通过返回的集合来完成的关键。

至关重要的是，用户手动同步，在返回时设置遍历它：

集的集合。synchronizedset（新hashset()）；…同步（s）迭代器我= S（）；//必须在同步块而（我hasnext()）foo（即next()）；}

未能遵循这个建议可能导致不确定的行为。

返回的集合如果指定的序列化是可串行化。

参数类型

T的对象集合中的类

参数

s -设置为“缠”在同步设置。

结果

指定的集合的同步视图。

synchronizedSortedSet

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

返回一个由指定的排序集支持的同步（线程安全）排序集。为了保证串行访问，这是 全部的访问支持排序集的关键是通过返回的有序集合（或意见）。

至关重要的是，用户手动同步返回排序集当遍历它或它的任何subSet，headSet，或tailSet观点。

SortedSet s =集合。synchronizedsortedset（新treeset()）；…同步（s）迭代器我= S（）；//必须在同步块而（我hasnext()）foo（即next()）；}

或：

SortedSet s =集合。synchronizedsortedset（新treeset()）；SortedSet S2 = s.headset（Foo）；…同步（s）{ //注：S2的，不！！！迭代器我= S2。（）；//必须在同步块而（我hasnext()）foo（即next()）；}

未能遵循这个建议可能导致不确定的行为。

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

参数类型

T的对象集合中的类

参数

s -排序是“包裹”在一个同步的有序集合。

结果

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

synchronizedNavigableSet

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

返回由指定的导航集支持的同步（线程安全）导航集。为了保证串行访问，这是 全部的访问支持通航设置是通过恢复通航设置完成关键（或意见）。

至关重要的是，用户手动同步返回的通航时，遍历它或它的任何subSet，headSet，或tailSet观点。

navigableset =集合。synchronizednavigableset（新treeset()）；…同步（s）迭代器我= S（）；//必须在同步块而（我hasnext()）foo（即next()）；}

或：

navigableset =集合。synchronizednavigableset（新treeset()）；navigableset S2 = s.headset（Foo，真的）；…同步（s）{ //注：S2的，不！！！迭代器我= S2。（）；//必须在同步块而（我hasnext()）foo（即next()）；}

未能遵循这个建议可能导致不确定的行为。

返回的通航将如果指定通航设置序列化是可串行化。

参数类型

T的对象集合中的类

参数

s -是“包裹”在一个同步的通航通航集集

结果

指定的可导航集的同步视图

从以下版本开始：

一点八

synchronizedList

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

返回由指定列表支持的同步（线程安全）列表。为了保证串行访问，这是 全部的访问支持列表是通过返回列表完成的关键。

至关重要的是，用户手动同步返回列表遍历它时：

列表的集合。synchronizedlist（新arraylist()）；…同步（列表）迭代器我=清单。（）；//必须同步块而（我hasnext()）foo（即next()）；}

未能遵循这个建议可能导致不确定的行为。

返回的列表如果指定列表序列化是可串行化。

参数类型

T的对象列表中的类

参数

list的名单是“缠”在同步列表。

结果

指定列表的同步视图。

synchronizedMap

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

返回由指定的Map支持的同步（线程安全）Map。为了保证串行访问，这是 全部的进入支持Map是通过返回的Map完成的关键。

至关重要的是，用户手动同步返回的Map时，遍历其任何集合视图：

MapM =集合。synchronizedmap（新hashmap()）；…集合S = M keyset()；/ /不必在同步块…同步（M）{ / /同步对M，而不是！迭代器我= S（）；//必须同步块而（我hasnext()）foo（即next()）；}

未能遵循这个建议可能导致不确定的行为。

返回的Map，如果指定的Map是可序列化是可串行化。

参数类型

KMap的关键类

VMap的价值类

参数

m -Map被“包裹”在一个同步的Map。

结果

指定的映射的同步视图。

synchronizedSortedMap

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

返回一个由指定的排序映射支持的同步（线程安全）排序的Map。为了保证串行访问，这是 全部的访问支持排序图是通过返回的排序图完成的关键（或意见）。

至关重要的是，用户手动同步时返回排序图遍历其任何集合视图，或集合视图的任何subMap，headMap或tailMap观点。

M =集合建模。synchronizedsortedmap（新treemap()）；…集合S = M keyset()；/ /不必在同步块…同步（M）{ / /同步对M，而不是！迭代器我= S（）；//必须同步块而（我hasnext()）foo（即next()）；}

或：

M =集合建模。synchronizedsortedmap（新treemap()）；M2 = m.submap建模（foo，bar）；…集合S2 =平方米。keyset()；/ /不必在同步块…同步（M）{ //同步的M，不是M2、S2！迭代器我= S（）；//必须同步块而（我hasnext()）foo（即next()）；}

未能遵循这个建议可能导致不确定的行为。

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

参数类型

KMap的关键类

VMap的价值类

参数

m -排序图是“包裹”在一个同步的排序图。

结果

指定的排序映射的同步视图。

synchronizedNavigableMap

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

返回指定的导航Map支持的同步（线程安全）导航Map。为了保证串行访问，这是 全部的访问支持导航电子Map是通过返回导航电子Map完成的关键（或意见）。

至关重要的是，用户手动同步返回导航电子Map当遍历其任何集合视图，或集合视图的任何subMap，headMap或tailMap观点。

navigablemap M =集合。synchronizednavigablemap（新treemap()）；…集合S = M keyset()；/ /不必在同步块…同步（M）{ / /同步对M，而不是！迭代器我= S（）；//必须同步块而（我hasnext()）foo（即next()）；}

或：

navigablemap M =集合。synchronizednavigablemap（新treemap()）；navigablemap M2 = m.submap（Foo，真的，酒吧，假）；…集合S2 =平方米。keyset()；/ /不必在同步块…同步（M）{ //同步的M，不是M2、S2！迭代器我= S（）；//必须同步块而（我hasnext()）foo（即next()）；}

未能遵循这个建议可能导致不确定的行为。

返回的导航电子Map将如果指定的导航电子Map是可序列化序列化。

参数类型

KMap的关键类

VMap的价值类

参数

m -是“包裹”在一个同步的导航电子Map的导航电子Map

结果

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

从以下版本开始：

一点八

checkedCollection

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被认为是一个价值的任何类型的引用，返回的集合允许插入null元素时收集不支持。

参数类型

E的对象集合中的类

参数

c -集合的动态类型安全的观点是要归还

type， c允许持有单元类型

结果

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

从以下版本开始：

一点五

checkedQueue

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

返回一个动态类型安全的查看指定队列。任何试图插入一个错误类型的元素将导致立即 ClassCastException。假设一个队列不包含错误类型的元素的时候产生一个动态类型安全的观点之前，和所有后续访问队列发生通过视图，它是放心，队列中不能包含一个错误类型的元素。

一种动态类型安全的使用意见，讨论可能的checkedCollection方法的文档中找到的。

返回队列，如果指定的队列序列化是可串行化。

因为null被认为是一个价值的任何类型的引用，返回队列中允许插入元素时null队列不支持。

参数类型

E -对象队列中的类

参数

queue -队列的动态类型安全的观点是要归还

type， queue允许持有单元类型

结果

动态类型安全的查看指定的队列

从以下版本开始：

一点八

checkedSet

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

返回一个指定的动态类型安全的观点。任何试图插入一个错误类型的元素将导致立即 ClassCastException。假设一个集合不包含错误类型的元素的时候产生一个动态类型安全的观点之前，和所有后续访问的设置是通过视图，它是放心，集不能包含一个错误类型的元素。

一种动态类型安全的使用意见，讨论可能的checkedCollection方法的文档中找到的。

返回的集合如果指定的序列化是可串行化。

因为null被认为是一个价值的任何类型的引用，返回的集合允许插入null元素时设置不支持。

参数类型

E的对象集合中的类

参数

s -设置为动态类型安全的观点是要归还

type， s允许持有单元类型

结果

动态类型安全的集合视图

从以下版本开始：

一点五

checkedSortedSet

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

返回一个动态类型安全的查看指定的排序设置。任何试图插入一个错误类型的元素将导致立即 ClassCastException。假设一个有序集合不包含错误类型的元素的时候产生一个动态类型安全的观点之前，和所有后续访问的排序发生通过视图，它是放心，排序集不能包含一个错误类型的元素。

一种动态类型安全的使用意见，讨论可能的checkedCollection方法的文档中找到的。

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

因为null被认为是一个价值的任何类型的引用，返回排序集允许插入null元素时不支持排序。

参数类型

E的对象集合中的类

参数

s -排序，动态类型安全的观点是要归还

type， s允许持有单元类型

结果

动态类型安全的查看指定的排序设置

从以下版本开始：

一点五

checkedNavigableSet

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

返回一个动态类型安全的集合视图指定通航。任何试图插入一个错误类型的元素将导致立即 ClassCastException。假设一个通航集不包含错误类型的元素的时候产生一个动态类型安全的观点之前，和所有后续访问的导航设置是通过视图，这是保证通航集不能包含一个错误类型的元素。

一种动态类型安全的使用意见，讨论可能的checkedCollection方法的文档中找到的。

返回的通航将如果指定通航设置序列化是可串行化。

因为null被认为是一个价值的任何类型的引用，返回的通航设置允许插入null元素时不支持排序。

参数类型

E的对象集合中的类

参数

s -通航设置为动态类型安全的观点是要归还

type， s允许持有单元类型

结果

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

从以下版本开始：

一点八

checkedList

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

返回一个动态类型安全的查看指定的列表。任何试图插入一个错误类型的元素将导致立即 ClassCastException。假设一个列表不包含错误类型的元素的时候产生一个动态类型安全的观点之前，和所有后续的访问列表是通过视图，它是放心，列表不能包含一个错误类型的元素。

一种动态类型安全的使用意见，讨论可能的checkedCollection方法的文档中找到的。

返回的列表如果指定列表序列化是可串行化。

因为null被认为是一个价值的任何类型的引用，返回列表允许插入null元素时，不支持列表。

参数类型

E的对象列表中的类

参数

list -列表中动态类型安全的观点是要归还

type， list允许持有单元类型

结果

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

从以下版本开始：

一点五

checkedMap

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

返回一个动态类型安全的查看指定的Map。任何试图插入一个映射的键或值的类型错误将导致立即 ClassCastException。同样，任何试图修改的值与当前相关会导致立即 ClassCastException是否修改，尝试直接通过Map本身，或从Map的 entry set观点得到 Map.Entry实例。

假设一个Map不包含错误类型的键或值时产生一个动态类型安全的观点之前，和所有后续访问的Map是通过视图（或它的一个集合视图），它是放心，Map不能包含不正确的键或值。

一种动态类型安全的使用意见，讨论可能的checkedCollection方法的文档中找到的。

返回的Map，如果指定的Map是可序列化是可串行化。

因为null被认为是一个价值的任何类型的引用，返回Map允许插入空键或值时不支持Map。

参数类型

KMap的关键类

VMap的价值类

参数

m -Map，动态类型安全的观点是要归还

keyType -重点， m允许持有型

valueType， m允许持有价值型

结果

动态类型安全的查看指定的Map

从以下版本开始：

一点五

checkedSortedMap

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

返回一个动态类型安全的查看指定的排序图。任何试图插入一个映射的键或值的类型错误将导致立即 ClassCastException。同样，任何试图修改的值与当前相关会导致立即 ClassCastException是否修改，尝试直接通过Map本身，或从Map的 entry set观点得到 Map.Entry实例。

假设一个Map不包含错误类型的键或值时产生一个动态类型安全的观点之前，和所有后续访问的Map是通过视图（或它的一个集合视图），它是放心，Map不能包含不正确的键或值。

一种动态类型安全的使用意见，讨论可能的checkedCollection方法的文档中找到的。

返回的Map，如果指定的Map是可序列化是可串行化。

因为null被认为是一个价值的任何类型的引用，返回Map允许插入空键或值时不支持Map。

参数类型

KMap的关键类

VMap的价值类

参数

m -Map，动态类型安全的观点是要归还

keyType -重点， m允许持有型

valueType， m允许持有价值型

结果

动态类型安全的查看指定的Map

从以下版本开始：

一点五

checkedNavigableMap

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

返回一个动态类型安全的查看指定的导航电子Map。任何试图插入一个映射的键或值的类型错误将导致立即 ClassCastException。同样，任何试图修改的值与当前相关会导致立即 ClassCastException是否修改，尝试直接通过Map本身，或从Map的 entry set观点得到 Map.Entry实例。

假设一个Map不包含错误类型的键或值时产生一个动态类型安全的观点之前，和所有后续访问的Map是通过视图（或它的一个集合视图），它是保证Map不能包含不正确的键或值。

一种动态类型安全的使用意见，讨论可能的checkedCollection方法的文档中找到的。

返回的Map，如果指定的Map是可序列化是可串行化。

因为null被认为是一个价值的任何类型的引用，返回Map允许插入空键或值时不支持Map。

参数类型

K -Map键型

V -映射值类型

参数

m -Map，动态类型安全的观点是要归还

keyType -重点， m允许持有型

valueType， m允许持有价值型

结果

动态类型安全的查看指定的Map

从以下版本开始：

一点八

emptyIterator

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

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

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

此方法的实现是允许的，但不是必需的，返回多个调用同一个对象。

参数类型

T型元素，如果有，在迭代器

结果

一个空的迭代器

从以下版本开始：

一点七

emptyListIterator

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

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

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

此方法的实现是允许的，但不是必需的，返回多个调用同一个对象。

参数类型

T型元素，如果有，在迭代器

结果

空列表迭代器

从以下版本开始：

一点七

emptyEnumeration

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

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

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

此方法的实现是允许的，但不是必需的，返回多个调用同一个对象。

参数类型

T -对象的枚举中的类

结果

一个空的枚举

从以下版本开始：

一点七

emptySet

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

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

这个例子说明了类型安全的方法来获得一个空集：

 
            
            
            
          
            
          <字符串>
           
             
           
             
             
             
  设置的集合。emptyset()；
 
            
            
            
          
            
          

Implementation Note:

该方法的实现不需要为每次调用创建一个单独的 Set对象。使用这种方法很可能有类似的成本，使用类似命名字段。（不像这种方法，字段不提供类型安全。）

参数类型

T的对象集合中的类

结果

空集合

从以下版本开始：

一点五

另请参见：

EMPTY_SET

emptySortedSet

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

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

这个例子说明了类型安全的方法来获得一个空的排序集：

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

Implementation Note:

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

参数类型

E型元素，如果有，在集

结果

空排序集

从以下版本开始：

一点八

emptyNavigableSet

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

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

这个例子说明了类型安全的方式来获得一个空的导航集：

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

Implementation Note:

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

参数类型

E型元素，如果有，在集

结果

空航集

从以下版本开始：

一点八

emptyList

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

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

这个例子说明了类型安全的方法来获得一个空列表：

列表
 
            
            
            
          
            
          <字符串>
           
             
           
             
             
             
   emptylist()的集合；
 
            
            
            
          
            
          

实施注：此方法的实现不需要为每次调用创建一个单独的 List对象。使用这种方法很可能有类似的成本，使用类似命名字段。（不像这种方法，字段不提供类型安全。）

参数类型

T型元素，如果有，在列表中

结果

一个空的不可改变的列表

从以下版本开始：

一点五

另请参见：

EMPTY_LIST

emptyMap

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

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

这个例子说明了类型安全的方法来获得一个空的Map：

图
 
            
            
            
          
            
          <字符串、日期>
           
             
           
             
             
             
  的emptymap()收藏；
 
            
            
            
          
            
          

Implementation Note:

该方法的实现不需要为每次调用创建一个单独的 Map对象。使用这种方法很可能有类似的成本，使用类似命名字段。（不像这种方法，字段不提供类型安全。）

参数类型

KMap的关键类

VMap的价值类

结果

一个空的Map

从以下版本开始：

一点五

另请参见：

EMPTY_MAP

emptySortedMap

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

返回一个空的排序映射（不可变）。这张Map是可序列化。

这个例子说明了类型安全的方法来获得一个空的Map：

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

Implementation Note:

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

参数类型

KMap的关键类

VMap的价值类

结果

一个空的排序映射

从以下版本开始：

一点八

emptyNavigableMap

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

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

这个例子说明了类型安全的方法来获得一个空的Map：

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

Implementation Note:

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

参数类型

KMap的关键类

VMap的价值类

结果

一个空的通航Map

从以下版本开始：

一点八

singleton

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

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

参数类型

T的对象集合中的类

参数

o -被存储在返回的唯一对象。

结果

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

singletonList

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

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

参数类型

T的对象列表中的类

参数

o -被存储在返回列表中的唯一目标。

结果

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

从以下版本开始：

一点三

singletonMap

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

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

参数类型

KMap的关键类

VMap的价值类

参数

key -被存储在返回Map的唯一关键。

value的值，返回MapMap key。

结果

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

从以下版本开始：

一点三

nCopies

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

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

参数类型

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

参数

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

o -元素在返回列表中多次出现。

结果

不可变列表包含指定对象的 n副本。

异常

如果 n < 0 IllegalArgumentException

另请参见：

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

reverseOrder

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

返回一个比较器，对一系列的实施 Comparable界面对象的自然顺序相反。（自然顺序排序的对象自身的 compareTo方法。实施）这使一个简单的成语进行分类（或维持）的集合（或数组），实现 Comparable界面反自然秩序的对象。例如，假设 a是字符串数组。然后：

阵列。排序（A，集合。reverseorder()）；

类反向字典数组（字母）顺序。

返回的比较器可序列化。

参数类型

T -类的对象进行比较

结果

一个比较器，一个集合，实现 Comparable界面对象征收的自然排序反向。

另请参见：

Comparable

reverseOrder

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

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

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

参数类型

T -类的对象进行比较

参数

cmp -比较器谁的排序是由返回的比较器或 null逆转

结果

规定指定比较器的反向排序的比较器。

从以下版本开始：

一点五

enumeration

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

返回指定集合的枚举数。这提供了与需要一个枚举作为输入的传统的应用程序的互操作性。

参数类型

T的对象集合中的类

参数

c -集合的枚举返回。

结果

在指定集合上的枚举。

另请参见：

Enumeration

list

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

返回一个数组列表，该列表包含在返回的顺序中由枚举返回的元素的元素。这种方法提供了互操作性的遗产API返回枚举和新的API，需要集合。

参数类型

T -类的对象返回的枚举

参数

e枚举提供返回的数组列表元素

结果

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

从以下版本开始：

一点四

另请参见：

Enumeration， ArrayList

frequency

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

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

参数

c -其中的收集确定 o频率

o的频率来确定对象

结果

在 c等于 o元素个数

异常

NullPointerException -如果 c是空的

从以下版本开始：

一点五

disjoint

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

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

必须注意如果这种方法用于收藏，不符合Collection一般合同。实现可以遍历集合和在其他的收集容器测试（或执行任何等效计算）。如果收集使用一个非平等测试（作为一个SortedSet的顺序不等于不兼容，或一个IdentityHashMap键设置），都必须使用相同的标准集合相等测试，或这种方法的结果是不确定的。

使用对它们可能包含的元素有限制的集合时，也必须小心行使。采集的实现是允许把任何他们认为不合格的操作异常涉及的元素。对于绝对安全，指定的集合应该包含只有两个集合的符合条件的元素的元素。

值得注意的是，它允许在参数传递相同的集合，在这种情况下，该方法将当且仅当集合为空返回true。

参数

c1 -集合

c2 -集合

结果

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

异常

NullPointerException -如果集合是 null。

NullPointerException -如果一个集合包含 null元和 null不是另一个合格的元素集合。（ optional）

ClassCastException -如果一个集合包含一个元素，一种是不适合其他收集。（ optional）

从以下版本开始：

一点五

addAll

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

将所有指定的元素添加到指定的集合中。添加的元素可以单独或作为一个数组来指定。这个方便的方法的行为， c.addAll(Arrays.asList(elements))相同，但这种方法可能运行速度明显加快，在大多数的实现。

当元素被单独指定时，该方法提供了一个方便的方式来添加一些元素到一个现有的集合中：

集合。所有（口味，“桃子”N钚”、“Rocky Racoon”）；

参数类型

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

参数

c -收集到 elements要插入

elements -插入的元素 c

结果

true如果调用的结果集的改变

异常

UnsupportedOperationException -如果 c不支持 add操作

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

IllegalArgumentException -如果一个价值 elements一些物业阻止其加入 c

从以下版本开始：

一点五

另请参见：

Collection.addAll(Collection)

newSetFromMap

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

返回一个由指定的映射支持的集合。由此产生的集显示相同的顺序、并发性和性能特性作为支持Map。在本质上，这个工厂方法提供相应的任何 Map实施 Set实施。没有必要用这种方法在 Map实施已经有相应的 Set实施（如 HashMap或 TreeMap）。

用这种方法的结果是一个方法调用的支持Map或其keySet视图返回的集合中的每个方法调用，有一个例外。的addAll方法是依托Map的序列put调用的实现。

指定的映射必须是空的，在这个方法被调用的时候，不应该在这个方法返回后直接访问。这些条件是确保如果映射创建空的，直接传递到这个方法，并没有引用到Map被保留，如下面的代码片段所示：

集
 
            
            
            
          
            
          <对象>
           
             
           
             
             
             
   weakhashset =集合。newsetfrommap（新<< WeakHashMap对象，布尔>（））；
 
            
            
            
          
            
          

参数类型

E -类Map键和对象返回的集合

参数

map -支持Map

结果

Map支持的集合

异常

IllegalArgumentException -如果 map不是空的

从以下版本开始：

一点六

asLifoQueue

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

返回一个 Deque视图为后进先出（LIFO） Queue。方法 add映射到 push， remove映射到 pop等等。这种观点可能是有用的当你想使用的方法，但你需要订购 Queue后进先出法。

用这种方法的结果是一个方法调用的返回在deque队列支持每个方法调用，有一个例外。的addAll方法是依托deque实现addFirst调用序列。

参数类型

T -在deque对象类

参数

deque - deque

结果

队列

从以下版本开始：

一点六