1. 首页
  2. JavaAPI

Java java.util 类 Collections（JDK5）

154 阅读 0 评论

所有类

概述  软件包   类  使用  树  已过时  索引  帮助 
摘要： 嵌套 | 字段 | 构造方法 | 方法 详细信息： 字段 | 构造方法 | 方法

java.util
类 Collections

java.lang.Object
  继承者 java.util.Collections

public class Collections
   
   
   
   
   
extends Object

此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。

如果为此类的方法所提供的 collection 或类对象为 null，则这些方法都会抛出 NullPointerException。

此类中所含多态算法的文档通常都包括对实现 的简短描述。应该将这类实现视为实现注意事项，而不是将它们视为规范 的一部分。实现者应该可以随意使用其他算法替代，只要遵循规范本身即可。（例如，sort 使用的算法不一定是一个合并排序算法，但它必须是稳定的。）

如果该 collection 不支持适当的可变基元，比如 set 方法，则此类中包含的“破坏性”算法，即可修改其所操作的 collection 的算法，被指定抛出 UnsupportedOperationException。如果调用不会对 collection 产生任何影响，那么这些算法可能（但不一定）抛出此异常。例如，在已经排序的、不可修改列表上调用 sort 方法可能会（也可能不会）抛出 UnsupportedOperationException。

此类是 Java Collections Framework 的成员。

从以下版本开始：
1.2
另请参见：
Collection, Set, List, Map

字段摘要
static List EMPTY_LIST
          空的列表（不可变的）。
static Map EMPTY_MAP
          空的映射（不可变的）。
static Set EMPTY_SET
          空的 set（不可变的）。
 
方法摘要
static
<T> boolean
addAll(Collection<? super T> c, T... a)
          将所有指定元素添加到指定 collection 中。
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)
          返回指定 collection 的一个动态类型安全视图。
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
<E> Set<E>
checkedSet(Set<E> s, Class<E> type)
          返回指定 set 的一个动态类型安全视图。
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)
          返回指定有序 set 的一个动态类型安全视图。
static
<T> void
copy(List<? super T> dest, List<? extends T> src)
          将所有元素从一个列表复制到另一个列表。
static boolean disjoint(Collection<?> c1, Collection<?> c2)
          如果两个指定 collection 中没有相同的元素，则返回 true。
static
<T> List<T>
emptyList()
          返回空的列表（不可变的）。
static
<K,V> Map<K,V>
emptyMap()
          返回空的映射（不可变的）。
static
<T> Set<T>
emptySet()
          返回空的 set（不可变的）。
static
<T> Enumeration<T>
enumeration(Collection<T> c)
          返回一个指定 collection 上的枚举。
static
<T> void
fill(List<? super T> list, T obj)
          使用指定元素替换指定列表中的所有元素。
static int frequency(Collection<?> c, Object o)
          返回指定 collection 中等于指定对象的元素数。
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)
          根据元素的自然顺序，返回给定 collection 的最大元素。
static
<T> T
max(Collection<? extends T> coll, Comparator<? super T> comp)
          根据指定比较器产生的顺序，返回给定 collection 的最大元素。
static
<T extends Object & Comparable<? super T>>
T
min(Collection<? extends T> coll)
          根据元素的自然顺序 返回给定 collection 的最小元素。
static
<T> T
min(Collection<? extends T> coll, Comparator<? super T> comp)
          根据指定比较器产生的顺序，返回给定 collection 的最小元素。
static
<T> List<T>
nCopies(int n, T o)
          返回由指定对象的 n 个副本组成的不可变列表。
static
<T> boolean
replaceAll(List<T> list, T oldVal, T newVal)
          使用另一个值替换列表中出现的所有某一指定值。
static void reverse(List<?> list)
          反转指定列表中元素的顺序。
static
<T> Comparator<T>
reverseOrder()
          返回一个比较器，它强行反转实现 Comparable 接口那些对象 collection 上的自然顺序。
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)
          返回一个只包含指定对象的不可变 set。
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)
          根据元素的自然顺序 对指定列表按升序进行排序。
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)
          返回由指定 collection 支持的同步（线程安全的）collection。
static
<T> List<T>
synchronizedList(List<T> list)
          返回由指定列表支持的同步（线程安全的）列表。
static
<K,V> Map<K,V>
synchronizedMap(Map<K,V> m)
          返回由指定映射支持的同步（线程安全的）映射。
static
<T> Set<T>
synchronizedSet(Set<T> s)
          返回由指定 set 支持的同步（线程安全的）set。
static
<K,V> SortedMap<K,V>
synchronizedSortedMap(SortedMap<K,V> m)
          返回由指定有序映射支持的同步（线程安全的）有序映射。
static
<T> SortedSet<T>
synchronizedSortedSet(SortedSet<T> s)
          返回由指定有序 set 支持的同步（线程安全的）有序 set。
static
<T> Collection<T>
unmodifiableCollection(Collection<? extends T> c)
          返回指定 collection 的不可修改视图。
static
<T> List<T>
unmodifiableList(List<? extends T> list)
          返回指定列表的不可修改视图。
static
<K,V> Map<K,V>
unmodifiableMap(Map<? extends K,? extends V> m)
          返回指定映射的不可修改视图。
static
<T> Set<T>
unmodifiableSet(Set<? extends T> s)
          返回指定 set 的不可修改视图。
static
<K,V> SortedMap<K,V>
unmodifiableSortedMap(SortedMap<K,? extends V> m)
          返回指定有序映射的不可修改视图。
static
<T> SortedSet<T>
unmodifiableSortedSet(SortedSet<T> s)
          返回指定有序 set 的不可修改视图。
 
从类 java.lang.Object 继承的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

字段详细信息

EMPTY_SET

public static final Set EMPTY_SET
空的 set（不可变的）。此 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)
根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此外，列表中的所有元素都必须是可相互比较的（也就是说，对于列表中的任何 e1 和 e2 元素，e1.compareTo(e2) 不得抛出 ClassCastException）。

此排序被保证是稳定的：不会因调用 sort 方法而对相等的元素进行重新排序。

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

该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n log(n) 性能。 此实现将指定列表转储到一个数组中，并对数组进行排序，在重置数组中相应位置处每个元素的列表上进行迭代。这避免了由于试图对适当位置上的链接列表进行排序而产生的 n2 log(n) 性能。

参数：
list - 要排序的列表。
抛出：
ClassCastException - 如果列表包含不可相互比较的 的元素（例如，字符串和整数）。
UnsupportedOperationException - 如果指定列表的列表迭代器不支持 set 操作。
另请参见：
Comparable

sort

public static <T> void sort(List<T> list,
                            Comparator<? super T> c)
根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须是使用指定比较器可相互比较的（也就是说，对于列表中的任何 e1 和 e2 元素，c.compare(e1, e2) 不得抛出 ClassCastException）。

此排序被保证是稳定的：不会因调用 sort 方法而对相等的元素进行重新排序。

排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n log(n) 性能。 指定列表必须是可修改的，但不必是可大小调整的。此实现将指定列表转储到一个数组中，并对数组进行排序，在重置数组中相应位置处每个元素的列表上进行迭代。这避免了由于试图对适当位置上的链接列表进行排序而产生的 n2 log(n) 性能。

参数：
list - 要排序的列表。
c - 确定列表顺序的比较器。null 值指示应该使用的元素的自然顺序。
抛出：
ClassCastException - 如果列表中包含使用指定的比较器不可相互比较的 的元素。
UnsupportedOperationException - 如果指定列表的列表迭代器不支持 set 操作。
另请参见：
Comparator

binarySearch

public static <T> int binarySearch(List<? extends Comparable<? super T>> list,
                                   T key)
使用二进制搜索算法来搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自然顺序 对列表进行升序排序（通过上面的 sort(List) 方法）。如果没有对列表进行排序，则结果是不明确的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。

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

参数：
list - 要搜索的列表。
key - 要搜索的键。
返回：
如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
抛出：
ClassCastException - 如果列表中包含不可相互比较 的元素（例如，字符串和整数），或者搜索键无法与列表的元素进行相互比较。
另请参见：
Comparable, sort(List)

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

参数：
list - 要搜索的列表。
key - 要搜索的键。
c - 排序列表的比较器。null 值指示应该使用的元素的自然顺序。
返回：
如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
抛出：
ClassCastException - 如果列表中包含使用指定的比较器不可相互比较 的元素，或者使用此比较器无法相互比较搜索键与列表的元素。
另请参见：
Comparable, sort(List, Comparator)

reverse

public static void reverse(List<?> list)
反转指定列表中元素的顺序。

此方法以线性时间运行。

参数：
list - 元素反转的列表。
抛出：
UnsupportedOperationException - 如果指定列表或其列表迭代器不支持 set 方法。

微信小程序

微信扫一扫体验

微信公众账号

微信扫一扫加关注

 发表
评论 返回
顶部