- java.lang.Object
-
- java.util.Collections
-
public class Collections extends Object
此类仅包含对集合进行操作或返回集合的静态方法。 它包含对集合进行操作的多态算法,“包装器”,它返回由指定集合支持的新集合,以及其他一些可能性和结束。如果提供给它们的集合或类对象为null,则此类的方法都抛出
NullPointerException
。包含在这个类中的多态算法的文档通常包括执行情况的简短描述。 这些描述应被视为实施说明 ,而不是规范的一部分 。 只要遵守规范本身,实现者就可以随意替换其他算法。 (例如,
sort
使用的算法不一定是mergesort,但它必须是稳定的 。)如果集合不支持适当的变异原语(例如
set
方法),则此类中包含的“破坏性”算法(即修改它们运行的集合的算法)被指定为抛出UnsupportedOperationException
。 如果调用对集合没有影响,则这些算法可能(但不是必须)抛出此异常。 例如,在已经排序的不可修改列表上调用sort
方法可能会也可能不会抛出UnsupportedOperationException
。本课程是Java Collections Framework的成员。
- 从以下版本开始:
- 1.2
- 另请参见:
-
Collection
,Set
,List
,Map
-
-
方法摘要
所有方法 静态方法 具体的方法 变量和类型 方法 描述 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()
返回一个空列表(不可变)。static <T> ListIterator<T>
emptyListIterator()
返回没有元素的列表迭代器。static <K,V>
Map<K,V>emptyMap()
返回一个空映射(不可变)。static <K,V>
NavigableMap<K,V>emptyNavigableMap()
返回一个空的可导航地图(不可变)。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>>
Tmax(Collection<? extends T> coll)
根据元素的 自然顺序返回给定集合的最大元素。static <T> T
max(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定比较器引发的顺序返回给定集合的最大元素。static <T extends Object & Comparable<? super T>>
Tmin(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
接口的对象集合强制执行 自然排序的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>>
voidsort(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)
返回指定集合的 unmodifiable view 。static <T> List<T>
unmodifiableList(List<? extends T> list)
返回指定列表的 unmodifiable view 。static <K,V>
Map<K,V>unmodifiableMap(Map<? extends K,? extends V> m)
返回指定映射的 unmodifiable view 。static <K,V>
NavigableMap<K,V>unmodifiableNavigableMap(NavigableMap<K,? extends V> m)
返回指定的可导航地图的 unmodifiable view 。static <T> NavigableSet<T>
unmodifiableNavigableSet(NavigableSet<T> s)
返回指定的可导航集的 unmodifiable view 。static <T> Set<T>
unmodifiableSet(Set<? extends T> s)
返回指定集的 unmodifiable view 。static <K,V>
SortedMap<K,V>unmodifiableSortedMap(SortedMap<K,? extends V> m)
返回指定有序映射的 unmodifiable view 。static <T> SortedSet<T>
unmodifiableSortedSet(SortedSet<T> s)
返回指定有序集的 unmodifiable view 。
-
-
-
字段详细信息
-
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
空映射(不可变)。 此地图是可序列化的。- 从以下版本开始:
- 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:
-
此实现
遵循使用指定列表的
List.sort(Comparator)
方法和null
比较器。 - 参数类型
-
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
- 用于排序列表的比较器。null
值表示应使用元素' natural ordering 。 - 结果
-
搜索关键字的索引,如果它包含在列表中;
否则,
(-(insertion point) - 1)
。 插入点定义为键将插入列表的点:第一个元素的索引大于键,或者如果列表中的所有元素都小于指定键,list.size()
。 请注意,当且仅当找到密钥时,这才能保证返回值> = 0。 - 异常
-
ClassCastException
-如果列表中包含使用指定的比较器不可 相互比较的元素,或者检索关键字是不使用此比较的列表的元素相互比较。
-
reverse
public static void reverse(List<?> list)
反转指定列表中元素的顺序。此方法以线性时间运行。
- 参数
-
list
- 要反转其元素的列表。 - 异常
-
UnsupportedOperationException
- 如果指定的列表或其list-iterator不支持set
操作。
-
shuffle
public static void shuffle(List<?> list)
使用默认的随机源随机置换指定的列表。 所有排列都以大致相等的可能性发生。在前面的描述中使用对冲“近似”,因为默认的随机性源仅是近似独立选择的比特的无偏源。 如果它是随机选择的比特的完美来源,则算法将选择具有完美均匀性的排列。
该实现向后遍历列表,从最后一个元素到第二个元素,重复地将随机选择的元素交换到“当前位置”。 从列表中从第一个元素到当前位置(包括第一个元素)的部分随机选择元素。
此方法以线性时间运行。 如果指定的列表未实现
RandomAccess
接口并且很大,则此实现会在将其重新排列之前将指定的列表转储到数组中,并将重排的数组转储回列表中。 这避免了在适当的位置改组“顺序访问”列表所导致的二次行为。- 参数
-
list
- 要洗牌的清单。 - 异常
-
UnsupportedOperationException
- 如果指定的列表或其list-iterator不支持set
操作。
-
shuffle
public static void shuffle(List<?> list, Random rnd)
使用指定的随机源随机置换指定的列表。 假设随机源是公平的,所有排列都以相同的可能性发生。该实现向后遍历列表,从最后一个元素到第二个元素,重复地将随机选择的元素交换到“当前位置”。 从列表中从第一个元素到当前位置(包括第一个元素)的部分随机选择元素。
此方法以线性时间运行。 如果指定的列表未实现
RandomAccess
接口并且很大,则此实现会在将其重新排列之前将指定的列表转储到数组中,并将混洗的数组转储回列表中。 这避免了在适当的位置改组“顺序访问”列表所导致的二次行为。- 参数
-
list
- 要洗牌的清单。 -
rnd
- 用于随机播放列表的随机源。 - 异常
-
UnsupportedOperationException
- 如果指定的列表或其list-iterator不支持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
- 如果指定的列表或其list-iterator不支持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
- 用于确定最小元素的比较器。 值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
抛出ClassCastException
)。此方法遍历整个集合,因此需要与集合大小成比例的时间。
- 参数类型
-
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
- 用于确定最大元素的比较器。null
值表示应使用元素的自然顺序 。 - 结果
- 根据指定的比较器,给定集合的最大元素。
- 异常
-
ClassCastException
- 如果集合包含使用指定比较器无法 相互比较的元素。 -
NoSuchElementException
- 如果集合为空。 - 另请参见:
-
Comparable
-
rotate
public static void rotate(List<?> list, int distance)
按指定距离旋转指定列表中的元素。 在调用此方法之后,索引i
处的元素将是先前在索引(i - distance)
modlist.size()
处的元素,对于0
和list.size()-1
(包括i
之间的所有值i
。 (此方法对列表的大小没有影响。)例如,假设
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
- 如果指定的列表或其list-iterator不支持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
- 如果指定的列表或其list-iterator不支持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
。 - 结果
- 指定源列表中第一次出现指定目标列表的起始位置,如果不存在,则返回-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
。 - 结果
- 指定源列表中指定目标列表最后一次出现的起始位置,如果不存在,则返回-1。
- 从以下版本开始:
- 1.4
-
unmodifiableCollection
public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c)
返回指定集合的unmodifiable view 。 对返回的集合的查询操作“读取”到指定的集合,并尝试修改返回的集合,无论是直接还是通过其迭代器,都会产生UnsupportedOperationException
。返回的集合不将hashCode并传递给底层集合等于操作,而是依赖于
Object
的equals
种hashCode
方法。 在后备集合是集合或列表的情况下,这对于保留这些操作的合同是必要的。如果指定的集合是可序列化的,则返回的集合将是可序列化的。
- 参数类型
-
T
- 集合中对象的类 - 参数
-
c
- 要返回不可修改视图的集合。 - 结果
- 指定集合的不可修改视图。
-
unmodifiableSet
public static <T> Set<T> unmodifiableSet(Set<? extends T> s)
返回指定集的unmodifiable view 。 查询对返回集合“读取”到指定集合的操作,并尝试修改返回的集合,无论是直接还是通过其迭代器,都会产生UnsupportedOperationException
。如果指定的集是可序列化的,则返回的集将是可序列化的。
- 参数类型
-
T
- 集合中对象的类 - 参数
-
s
- 要返回不可修改视图的集合。 - 结果
- 指定集的不可修改的视图。
-
unmodifiableSortedSet
public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)
返回指定有序集的unmodifiable view 。 对返回的有序集合“查询”对指定的有序集的查询操作。 试图修改返回的有序集合,无论是直接的,通过其迭代器,或通过其subSet
,headSet
,或tailSet
意见,导致UnsupportedOperationException
。如果指定的有序集是可序列化的,则返回的有序集将是可序列化的。
- 参数类型
-
T
- 集合中对象的类 - 参数
-
s
- 要为其返回不可修改视图的有序集。 - 结果
- 指定有序集的不可修改视图。
-
unmodifiableNavigableSet
public static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s)
返回指定可导航集的unmodifiable view 。 对返回的可导航集“查阅”对指定的可导航集的查询操作。 试图修改返回的导航set,不管是直接的,通过其迭代器,或通过其subSet
,headSet
,或tailSet
意见,导致UnsupportedOperationException
。如果指定的可导航集是可序列化的,则返回的可导航集将是可序列化的。
- 参数类型
-
T
- 集合中对象的类 - 参数
-
s
- 要返回不可修改视图的可导航集 - 结果
- 指定可导航集的不可修改视图
- 从以下版本开始:
- 1.8
-
unmodifiableList
public static <T> List<T> unmodifiableList(List<? extends T> list)
返回指定列表的unmodifiable view 。 对返回列表的查询操作“读取”到指定列表,并尝试修改返回的列表,无论是直接还是通过其迭代器,都会产生UnsupportedOperationException
。如果指定的列表是可序列化的,则返回的列表将是可序列化的。 同样,如果指定的列表,返回的列表将实现
RandomAccess
。- 参数类型
-
T
- 列表中对象的类 - 参数
-
list
- 要返回不可修改视图的列表。 - 结果
- 指定列表的不可修改的视图。
-
unmodifiableMap
public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m)
返回指定映射的unmodifiable view 。 对返回的地图上的查询操作“读取”到指定的地图,并尝试修改返回的地图,无论是直接还是通过其集合视图,都会产生UnsupportedOperationException
。如果指定的映射是可序列化的,则返回的映射将是可序列化的。
- 参数类型
-
K
- 地图键的类 -
V
- 地图值的类 - 参数
-
m
- 要返回不可修改视图的地图。 - 结果
- 指定地图的不可修改的视图。
-
unmodifiableSortedMap
public static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m)
返回指定有序映射的unmodifiable view 。 对返回的有序映射的查询操作“读取”到指定的有序映射。 试图修改返回的有序映射,无论是直接的,通过其收集的意见,或通过其subMap
,headMap
,或tailMap
意见,导致UnsupportedOperationException
。如果指定的有序映射是可序列化的,则返回的有序映射将是可序列化的。
- 参数类型
-
K
- 地图键的类 -
V
- 地图值的类 - 参数
-
m
- 要返回不可修改视图的有序映射。 - 结果
- 指定有序映射的不可修改视图。
-
unmodifiableNavigableMap
public static <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K,? extends V> m)
返回指定可导航地图的unmodifiable view 。 对返回的可导航地图的查询操作“读取”到指定的可导航地图。 试图修改返回的导航地图,无论是直接的,通过其收集的意见,或通过其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, 类<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, 类<E> type)
返回指定队列的动态类型安全视图。 任何插入错误类型元素的尝试都会立即导致ClassCastException
。 假设在生成动态类型安全视图之前队列不包含错误键入的元素,并且通过视图对队列的所有后续访问都发生,则可以保证队列不能包含错误键入的元素。有关动态类型安全视图使用的讨论可以在
checkedCollection
方法的文档中找到。如果指定的队列是可序列化的,则返回的队列将是可序列化的。
由于
null
被认为是任何引用类型的值,因此返回的队列允许在后备队列执行时插入null
元素。- 参数类型
-
E
- 队列中对象的类 - 参数
-
queue
- 要为其返回动态类型安全视图的队列 -
type
- 允许queue
持有的元素类型 - 结果
- 指定队列的动态类型安全视图
- 从以下版本开始:
- 1.8
-
checkedSet
public static <E> Set<E> checkedSet(Set<E> s, 类<E> type)
返回指定集的动态类型安全视图。 任何插入错误类型元素的尝试都会立即导致ClassCastException
。 假设在生成动态类型安全视图之前,集合不包含错误键入的元素,并且通过视图对集合的所有后续访问都发生,则可以保证集合不能包含错误键入的元素。有关动态类型安全视图使用的讨论可以在
checkedCollection
方法的文档中找到。如果指定的集是可序列化的,则返回的集将是可序列化的。
由于
null
被认为是任何引用类型的值,因此返回的集合允许在后备集合时插入空元素。- 参数类型
-
E
- 集合中对象的类 - 参数
-
s
- 要为其返回动态类型安全视图的集合 -
type
- 允许s
保留的元素类型 - 结果
- 指定集的动态类型安全视图
- 从以下版本开始:
- 1.5
-
checkedSortedSet
public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, 类<E> type)
返回指定有序集的动态类型安全视图。 任何插入错误类型元素的尝试都会立即导致ClassCastException
。 假设在生成动态类型安全视图之前,排序集不包含错误键入的元素,并且通过视图对排序集的所有后续访问都发生,则可以保证排序集不能包含错误键入的元素。有关动态类型安全视图使用的讨论可以在
checkedCollection
方法的文档中找到。如果指定的有序集是可序列化的,则返回的有序集将是可序列化的。
由于
null
被认为是任何引用类型的值,因此返回的有序集允许在后备排序集的情况下插入空元素。- 参数类型
-
E
- 集合中对象的类 - 参数
-
s
- 要为其返回动态类型安全视图的有序集 -
type
- 允许s
保留的元素类型 - 结果
- 指定有序集的动态类型安全视图
- 从以下版本开始:
- 1.5
-
checkedNavigableSet
public static <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s, 类<E> type)
返回指定可导航集的动态类型安全视图。 任何插入错误类型元素的尝试都会立即导致ClassCastException
。 假设在生成动态类型安全视图之前,可导航集不包含错误键入的元素,并且通过视图对导航集的所有后续访问都发生,则可保证可导航集不能包含错误键入的元素。有关动态类型安全视图使用的讨论可以在
checkedCollection
方法的文档中找到。如果指定的可导航集是可序列化的,则返回的可导航集将是可序列化的。
由于
null
被认为是任何引用类型的值,因此返回的可导航集允许在后备排序集的情况下插入空元素。- 参数类型
-
E
- 集合中对象的类 - 参数
-
s
- 要为其返回动态类型安全视图的可导航集 -
type
- 允许s
保留的元素类型 - 结果
- 指定可导航集的动态类型安全视图
- 从以下版本开始:
- 1.8
-
checkedList
public static <E> List<E> checkedList(List<E> list, 类<E> type)
返回指定列表的动态类型安全视图。 任何插入错误类型元素的尝试都会立即导致ClassCastException
。 假设在生成动态类型安全视图之前列表不包含错误键入的元素,并且所有后续访问列表都是通过视图进行的,则可以保证列表不能包含错误键入的元素。有关动态类型安全视图使用的讨论可以在
checkedCollection
方法的文档中找到。如果指定的列表是可序列化的,则返回的列表将是可序列化的。
由于
null
被认为是任何引用类型的值,因此返回列表允许在后备列表中插入空元素。- 参数类型
-
E
- 列表中对象的类 - 参数
-
list
- 要为其返回动态类型安全视图的列表 -
type
- 允许list
保留的元素类型 - 结果
- 指定列表的动态类型安全视图
- 从以下版本开始:
- 1.5
-
checkedMap
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
持有的值的类型 - 结果
- 指定映射的动态类型安全视图
- 从以下版本开始:
- 1.5
-
checkedSortedMap
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
持有的值的类型 - 结果
- 指定映射的动态类型安全视图
- 从以下版本开始:
- 1.5
-
checkedNavigableMap
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
持有的值的类型 - 结果
- 指定映射的动态类型安全视图
- 从以下版本开始:
- 1.8
-
emptyIterator
public static <T> Iterator<T> emptyIterator()
返回没有元素的迭代器。 更确切地说,-
hasNext
始终返回false
。 -
next
总是抛出NoSuchElementException
。 -
remove
总是抛出IllegalStateException
。
允许但不要求实现此方法,以从多个调用返回相同的对象。
- 参数类型
-
T
- 迭代器中的元素类型(如果有) - 结果
- 一个空的迭代器
- 从以下版本开始:
- 1.7
-
-
emptyListIterator
public static <T> ListIterator<T> emptyListIterator()
返回没有元素的列表迭代器。 更确切地说,-
hasNext
和hasPrevious
总是返回false
。 -
next
和previous
总是抛出NoSuchElementException
。 -
remove
和set
总是抛出IllegalStateException
。 -
add
总是抛出UnsupportedOperationException
。 -
nextIndex
总是返回0
。 -
previousIndex
总是返回-1
。
允许但不要求实现此方法,以从多个调用返回相同的对象。
- 参数类型
-
T
- 迭代器中的元素类型(如果有) - 结果
- 一个空列表迭代器
- 从以下版本开始:
- 1.7
-
-
emptyEnumeration
public static <T> Enumeration<T> emptyEnumeration()
返回没有元素的枚举。 更确切地说,-
hasMoreElements
始终返回false
。 -
nextElement
总是抛出NoSuchElementException
。
允许但不要求实现此方法,以从多个调用返回相同的对象。
- 参数类型
-
T
- 枚举中对象的类 - 结果
- 空的枚举
- 从以下版本开始:
- 1.7
-
-
emptySet
public static final <T> Set<T> emptySet()
返回一个空集(不可变)。 这个集是可序列化的。 与名称相同的字段不同,此方法是参数化的。此示例说明了获取空集的类型安全方法:
Set<String> s = Collections.emptySet();
- Implementation Note:
-
此方法的实现不需要为每个调用创建单独的
Set
对象。 使用此方法可能具有与使用类似命名字段相当的成本。 (与此方法不同,该字段不提供类型安全性。) - 参数类型
-
T
- 集合中对象的类 - 结果
- 空集
- 从以下版本开始:
- 1.5
- 另请参见:
-
EMPTY_SET
-
emptySortedSet
public static <E> SortedSet<E> emptySortedSet()
返回一个空的有序集(不可变)。 这个集是可序列化的。此示例说明了获取空排序集的类型安全方法:
SortedSet<String> s = Collections.emptySortedSet();
- Implementation Note:
-
此方法的实现不需要为每个调用创建单独的
SortedSet
对象。 - 参数类型
-
E
- 集合中的元素类型(如果有) - 结果
- 空的排序集
- 从以下版本开始:
- 1.8
-
emptyNavigableSet
public static <E> NavigableSet<E> emptyNavigableSet()
返回一个空的可导航集(不可变)。 这个集是可序列化的。此示例说明了获取空导航集的类型安全方法:
NavigableSet<String> s = Collections.emptyNavigableSet();
- Implementation Note:
-
此方法的实现不需要为每个调用创建单独的
NavigableSet
对象。 - 参数类型
-
E
- 集合中的元素类型(如果有) - 结果
- 空的可导航集
- 从以下版本开始:
- 1.8
-
emptyList
public static final <T> List<T> emptyList()
返回一个空列表(不可变)。 此列表是可序列化的。此示例说明了获取空列表的类型安全方法:
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()
返回一个空的有序映射(不可变)。 此地图是可序列化的。此示例说明了获取空映射的类型安全方法:
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
实现Comparable
接口的对象集合强制执行自然排序的Comparable
。 (自然排序是对象自己的compareTo
方法所强加的排序。)这使得一个简单的习惯用法可以按反向自然顺序排序(或维护)实现Comparable
接口的对象的集合(或数组)。 例如,假设a
是一个字符串数组。 然后:Arrays.sort(a, Collections.reverseOrder());
以反向字典(按字母顺序)顺序对数组进行排序。返回的比较器是可序列化的。
- 参数类型
-
T
- 比较器比较的对象类 - 结果
-
比较器,
Comparable
实现Comparable
接口的对象集合强制执行 自然排序的Comparable
。 - 另请参见:
-
Comparable
-
reverseOrder
public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
返回一个比较器,它强制指定比较器的反向排序。 如果指定的比较器是null
,则此方法等效于reverseOrder()
(换句话说,它返回一个比较器,该比较器对实现Comparable接口的对象集合强制执行自然排序的反转)。返回的比较器是可序列化的(假设指定的比较器也可序列化或
null
)。- 参数类型
-
T
- 比较器比较的对象类 - 参数
-
cmp
- 通过返回的比较器或null
将订购的比较器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
,其排序与equals不兼容 ,或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
不允许使用null元素,或者c
或elements
是null
-
IllegalArgumentException
-如果在一个值的某些属性elements
防止它被加入到c
- 从以下版本开始:
- 1.5
- 另请参见:
-
Collection.addAll(Collection)
-
newSetFromMap
public static <E> Set<E> newSetFromMap(Map<E,Boolean> map)
返回由指定映射支持的集合。 结果集显示与支持映射相同的排序,并发和性能特征。 在本质上,此工厂方法提供了一种Set
对应于任何执行Map
实现。 有没有必要使用这种方法对Map
已经有一个对应的实现Set
实现(如HashMap
或TreeMap
)。此方法返回的集合上的每个方法调用都会在后备映射或其
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
订购的方法时,此视图非常有用。此方法返回的队列上的每个方法调用都会在后备双端队列上产生一个方法调用,但有一个例外。
addAll
方法实现为后备双端队列上的一系列addFirst
调用。- 参数类型
-
T
- 双端队列中对象的类 - 参数
-
deque
-deque
- 结果
- 队列
- 从以下版本开始:
- 1.6
-
-