概述  软件包   类  使用  树  已过时  索引  帮助 
JavaTM Platform
Standard Ed. 6
 上一个类   下一个类 框架    无框架    
摘要： 嵌套 | 字段 | 构造方法 | 方法 详细信息： 字段 | 构造方法 | 方法

java.util
类 Collections

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

public class Collections
     

      extends 
      Object

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

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

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

此类中包含的“破坏性”算法，即可修改其所操作的 collection 的算法，该算法被指定在 collection 不支持适当的可变基元（比如 set 方法）时抛出 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... elements)
          将所有指定元素添加到指定 collection 中。
static
<T> Queue<T>
asLifoQueue(Deque<T> deque)
          以后进先出 (Lifo) Queue 的形式返回某个 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, 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
<E> Set<E>
newSetFromMap(Map<E,Boolean> map)
          返回指定映射支持的 set。
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 - 如果列表中包含不 可相互比较 的元素（例如，字符串和整数），或者搜索键无法与列表的元素进行相互比较。

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 - 如果列表中包含使用指定的比较器不 可相互比较 的元素，或者使用此比较器无法相互比较搜索键与列表元素。

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)
使用指定元素替换指定列表中的所有元素。

此方法以线性时间运行。

参数：
list - 使用指定元素填充的列表。
obj - 用来填充指定列表的元素。
抛出：
UnsupportedOperationException - 如果指定列表或其列表迭代器不支持 set 操作。

copy

public static <T> void copy(List<? super T> dest,
                            List<? extends T> src)
将所有元素从一个列表复制到另一个列表。执行此操作后，目标列表中每个已复制元素的索引将等同于源列表中该元素的索引。目标列表的长度至少必须等于源列表。如果目标列表更长一些，也不会影响目标列表中的其余元素。

此方法以线性时间运行。

参数：
dest - 目标列表。
src - 源列表。
抛出：
IndexOutOfBoundsException - 如果目标列表太小而无法包含整个源列表。
UnsupportedOperationException - 如果目标列表的列表迭代器不支持 set 操作。

min

public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
根据元素的 自然顺序 返回给定 collection 的最小元素。collection 中的所有元素都必须实现 Comparable 接口。此外，collection 中的所有元素都必须是 可相互比较的（也就是说，对于 collection 中的任意 e1 和 e2 元素， e1.compareTo(e2) 不得抛出 ClassCastException）。

此方法在整个 collection 上进行迭代，所以它需要的时间与 collection 的大小成正比。

参数：
coll - 将确定其最小元素的 collection。
返回：
根据元素的 自然顺序，返回给定 collection 的最小元素。
抛出：
ClassCastException - 如果 collection 包含不 可相互比较 的元素（例如，字符串和整数）。
NoSuchElementException - 如果 collection 为空。
另请参见：
Comparable

min

public static <T> T min(Collection<? extends T> coll,
                        Comparator<? super T> comp)
根据指定比较器产生的顺序，返回给定 collection 的最小元素。collection 中的所有元素都必须可通过指定比较器 相互比较（也就是说，对于 collection 中的任意 e1 和 e2 元素， comp.compare(e1, e2) 不得抛出 ClassCastException）。

此方法在整个 collection 上进行迭代，所以它需要的时间与 collection 的大小成正比。

参数：
coll - 将确定其最小元素的 collection。
comp - 用来确定最小元素的比较器。 null 值指示应该使用元素的 自然顺序。
返回：
根据指定比较器返回给定 collection 的最小元素。
抛出：
ClassCastException - 如果 collection 中包含不可使用指定比较器 相互比较 的元素。
NoSuchElementException - 如果 collection 为空。
另请参见：
Comparable

max

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
根据元素的 自然顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须实现 Comparable 接口。此外，collection 中的所有元素都必须是 可相互比较的（也就是说，对于 collection 中的任意 e1 和 e2 元素， e1.compareTo(e2) 不得抛出 ClassCastException）。

此方法在整个 collection 上进行迭代，所以它需要的时间与 collection 的大小成正比。

参数：
coll - 将确定其最大元素的 collection。
返回：
根据元素的 自然顺序 返回给定 collection 的最大元素。
抛出：
ClassCastException - 如果 collection 包含不 可相互比较 的元素（例如，字符串和整数）。
NoSuchElementException - 如果 collection 为空。
另请参见：
Comparable

max

public static <T> T max(Collection<? extends T> coll,
                        Comparator<? super T> comp)
根据指定比较器产生的顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须可通过指定比较器 相互比较（也就是说，对于 collection 中的任意 e1 和 e2 元素， comp.compare(e1, e2) 不得抛出 ClassCastException）。

此方法在整个 collection 上进行迭代，所以它需要的时间与 collection 的大小成正比。

参数：
coll - 将确定其最大元素的 collection。
comp - 用来确定最大元素的比较器。 null 值指示应该使用元素的 自然顺序。
返回：
根据指定比较器返回给定 collection 的最大元素。
抛出：
ClassCastException - 如果 collection 中包含不可使用指定比较器 相互比较 的元素。
NoSuchElementException - 如果 collection 为空。
另请参见：
Comparable

rotate

public static void rotate(List<?> list,
                          int distance)
根据指定的距离轮换指定列表中的元素。调用此方法后，对于 0 和 list.size()-1（包括）之间的所有 i 值，索引 i 处的元素将是以前位于索引 (i - distance) mod list.size() 处的元素。（此方法对列表的大小没有任何影响。）

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

注意，此方法用于子列表时非常有用，可以在保留其余元素顺序的同时，在列表中移动一个或多个元素。例如，以下语句可以将索引 j 处的元素向前移动到位置 k 上（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 撰写的 Programming Pearls (Addison-Wesley, 1986) 一书中的第 2.3 小节。

参数：
list - 要轮换的列表。
distance - 列表轮换的距离。在此值上没有任何限制；它可以是 0、负数或大于 list.size() 的数。
抛出：
UnsupportedOperationException - 如果指定列表或其列表迭代器不支持 set 操作。
从以下版本开始：
1.4

replaceAll

public static <T> boolean replaceAll(List<T> list,
                                     T oldVal,
                                     T newVal)
使用另一个值替换列表中出现的所有某一指定值。更确切地讲，使用 newVal 替换 list 中满足 (oldVal==null ? e==null : oldVal.equals(e)) 的每个 e 元素。（此方法对列表的大小没有任何影响。）

参数：
list - 在其中进行替换的列表。
oldVal - 将被替换的原值。
newVal - 替换 oldVal 的新值。
返回：
如果 list 包含一个或多个满足 (oldVal==null ? e==null : oldVal.equals(e)) 的 e 元素，则返回 true。
抛出：
UnsupportedOperationException - 如果指定列表或其列表迭代器不支持 set 操作。
从以下版本开始：
1.4

indexOfSubList

public static int indexOfSubList(List<?> source,
                                 List<?> target)
返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。更确切地讲，返回满足 source.subList(i, i+target.size()).equals(target) 的最低索引 i；如果不存在这样的索引，则返回 -1。（如果 target.size() > source.size()，则返回 -1。）

此实现使用 "brute force" 扫描技术在源列表上进行扫描，依次在每个位置上寻找与目标匹配的列表项。

参数：
source - 在该列表中搜索第一次出现的 target。
target - 作为 source 子列表搜索的列表。
返回：
返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
从以下版本开始：
1.4

lastIndexOfSubList

public static int lastIndexOfSubList(List<?> source,
                                     List<?> target)
返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。更确切地讲，返回满足 source.subList(i, i+target.size()).equals(target) 的最高索引 i；如果不存在这样的索引，则返回 -1。（如果 target.size() > source.size()，则返回 -1。）

此实现使用 "brute force" 迭代技术在源列表上进行迭代，依次在每个位置上寻找与目标匹配的列表项。

参数：
source - 在该列表中搜索最后一次出现的 target。
target - 作为 source 子列表搜索的列表。
返回：
返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
从以下版本开始：
1.4

unmodifiableCollection

public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c)
返回指定 collection 的不可修改视图。此方法允许模块为用户提供对内部 collection 的“只读”访问。在返回的 collection 上执行的查询操作将“读完”指定的 collection。试图修改返回的 collection（不管是直接修改还是通过其迭代器进行修改）将导致抛出 UnsupportedOperationException。

返回的 collection 不会 将 hashCode 和 equals 操作传递给底层实现 collection，但这依赖于 Object 的 equals 和 hashCode 方法。在底层实现 collection 是一个 set 或是一个列表的情况下，有必要遵守这些操作的协定。

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

参数：
c - 将为其返回一个不可修改视图的 collection。
返回：
指定 collection 的不可修改视图。

unmodifiableSet

public static <T> Set<T> unmodifiableSet(Set<? extends T> s)
返回指定 set 的不可修改视图。此方法允许模块为用户提供对内部 set 的“只读”访问。在返回的 set 上执行的查询操作将“读完”指定的 set。试图修改返回的 set（不管是直接修改还是通过其迭代器进行修改）将导致抛出 UnsupportedOperationException。

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

参数：
s - 将为其返回一个不可修改视图的 set。
返回：
指定 set 的不可修改视图。

unmodifiableSortedSet

public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)
返回指定有序 set 的不可修改视图。此方法允许模块为用户提供对内部有序 set 的“只读”访问。在返回的有序 set 上执行的查询操作将“读完”指定的有序 set。试图修改返回的有序 set（无论是直接修改、通过其迭代器修改，还是通过其 subSet、 headSet 或 tailSet 视图修改）将导致抛出 UnsupportedOperationException。

如果指定有序 set 是可序列化的，则返回的有序 set 也将是可序列化的。

参数：
s - 将为其返回一个不可修改视图的有序 set。
返回：
指定有序 set 的不可修改视图。

unmodifiableList

public static <T> List<T> unmodifiableList(List<? extends T> list)
返回指定列表的不可修改视图。此方法允许模块为用户提供对内部列表的“只读”访问。在返回的列表上执行的查询操作将“读完”指定的列表。试图修改返回的列表（不管是直接修改还是通过其迭代器进行修改）将导致抛出 UnsupportedOperationException。

如果指定列表是可序列化的，则返回的列表也将是可序列化的。类似地，如果指定列表实现 RandomAccess，则返回列表也将这样做。

参数：
list - 将为其返回一个不可修改视图的列表。
返回：
指定列表的不可修改视图。

unmodifiableMap

public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m)
返回指定映射的不可修改视图。此方法允许模块为用户提供对内部映射的“只读”访问。在返回的映射上执行的查询操作将“读完”指定的映射。试图修改返回的映射（不管是直接修改还是通过其 collection 视图进行修改）将导致抛出 UnsupportedOperationException。

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

参数：
m - 将为其返回一个不可修改视图的映射。
返回：
指定映射的不可修改视图。

unmodifiableSortedMap

public static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m)
返回指定有序映射的不可修改视图。此方法允许模块为用户提供对内部有序映射的“只读”访问。在返回的有序映射上执行的查询操作将“读完”指定的有序映射。试图修改返回的有序映射（无论是直接修改、通过其 collection 视图修改，还是通过其 subMap、 headMap 或 tailMap 视图修改）将导致抛出 UnsupportedOperationException。

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

参数：
m - 将为其返回一个不可修改视图的有序映射。
返回：
指定有序映射的不可修改视图。

synchronizedCollection

public static <T> Collection<T> synchronizedCollection(Collection<T> c)
返回指定 collection 支持的同步（线程安全的）collection。为了保证按顺序访问，必须通过返回的 collection 完成 所有对底层实现 collection 的访问。

在返回的 collection 上进行迭代时，用户必须手工在返回的 collection 上进行同步： 

  Collection c = Collections.synchronizedCollection(myCollection);
     ...
  synchronized(c) {
      Iterator i = c.iterator(); // Must be in the synchronized block
      while (i.hasNext())
         foo(i.next());
  }
不遵从此建议将导致无法确定的行为。

返回的 collection 不会 将 hashCode 和 equals 操作传递给底层实现 collection，但这依赖于 Object 的 equals 和 hashCode 方法。在底层实现 collection 是一个 set 或一个列表的情况下，有必要遵守这些操作的协定。

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

参数：
c - 被“包装”在同步 collection 中的 collection。
返回：
指定 collection 的同步视图。

synchronizedSet

public static <T> Set<T> synchronizedSet(Set<T> s)
返回指定 set 支持的同步（线程安全的）set。为了保证按顺序访问，必须通过返回的 set 完成对 所有底层实现 set 的访问。

在返回的 set 上进行迭代时，用户必须手工在返回的 set 上进行同步： 

  Set s = Collections.synchronizedSet(new HashSet());
      ...
  synchronized(s) {
      Iterator i = s.iterator(); // Must be in the synchronized block
      while (i.hasNext())
          foo(i.next());
  }
不遵从此建议将导致无法确定的行为。

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

参数：
s - 被“包装”在同步 set 中的 set。
返回：
指定 set 的同步视图。

synchronizedSortedSet

public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)
返回指定有序 set 支持的同步（线程安全的）有序 set。为了保证按顺序访问，必须通过返回的有序 set（或其视图）完成对 所有底层实现有序 set 的访问。

在返回的有序 set 上或者其任意 subSet、headSet 或 tailSet 视图上进行迭代时，用户必须手工在返回的有序 set 上进行同步。 

  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());
  }
不遵从此建议将导致无法确定的行为。

如果指定的有序 set 是可序列化的，则返回的有序 set 也将是可序列化的。

参数：
s - 被“包装”在同步有序 set 中的有序 set。
返回：
指定有序 set 的同步视图。

synchronizedList

public static <T> List<T> synchronizedList(List<T> list)
返回指定列表支持的同步（线程安全的）列表。为了保证按顺序访问，必须通过返回的列表完成 所有对底层实现列表的访问。

在返回的列表上进行迭代时，用户必须手工在返回的列表上进行同步： 

  List list = Collections.synchronizedList(new ArrayList());
      ...
  synchronized(list) {
      Iterator i = list.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }
不遵从此建议将导致无法确定的行为。

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

参数：
list - 被“包装”在同步列表中的列表。
返回：
指定列表的同步视图。

synchronizedMap

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
返回由指定映射支持的同步（线程安全的）映射。为了保证按顺序访问，必须通过返回的映射完成 所有对底层实现映射的访问。

在返回映射的任意 collection 视图上进行迭代时，用户必须手工在返回的映射上进行同步： 

  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());
  }
不遵从此建议将导致无法确定的行为。

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

参数：
m - 被“包装”在同步映射中的映射。
返回：
指定映射的同步视图。

synchronizedSortedMap

public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
返回指定有序映射支持的同步（线程安全的）有序映射。为了保证按顺序访问，必须通过返回的有序映射（或其视图）完成对 所有底层有序映射的访问。

当在返回的有序映射的 collection 视图或者其任何 subMap、headMap 或 tailMap 视图进行迭代时，用户必须手工在该映射上进行同步： 

  SortedMap m = Collections.synchronizedSortedMap(new TreeMap());
      ...
  Set s = m.keySet();  // Needn't be in synchronized block
      ...
  synchronized(m) {  // Synchronizing on m, not s!
      Iterator i = s.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }
或者： 
  SortedMap m = Collections.synchronizedSortedMap(new TreeMap());
  SortedMap m2 = m.subMap(foo, bar);
      ...
  Set s2 = m2.keySet();  // Needn't be in synchronized block
      ...
  synchronized(m) {  // Synchronizing on m, not m2 or s2!
      Iterator i = s.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }
不遵从此建议将导致无法确定的行为。

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

参数：
m - 被“包装”在同步有序映射中的有序映射。
返回：
指定有序映射的同步视图。

checkedCollection

public static <E> Collection<E> checkedCollection(Collection<E> c,
                                                  Class<E> type)
返回指定 collection 的一个动态类型安全视图。试图插入一个错误类型的元素将导致立即抛出 ClassCastException。假设在生成动态类型安全视图之前，collection 不包含任何类型不正确的元素，并且所有对该 collection 的后续访问都通过该视图进行，则可以 保证 该 collection 不包含类型不正确的元素。

一般的编程语言机制中都提供了编译时（静态）类型检查，但是一些未经检查的强制转换可能会使此机制无效。通常这不是一个问题，因为编译器会在所有这类未经检查的操作上发出警告。但有的时候，只进行单独的静态类型检查并不够。例如，假设将 collection 传递给一个第三方库，则库代码不能通过插入一个错误类型的元素来毁坏 collection。

动态类型安全视图的另一个用途是调试。假设某个程序运行失败并抛出 ClassCastException，这指示一个类型不正确的元素被放入已参数化 collection 中。不幸的是，该异常可以发生在插入错误元素之后的任何时间，因此，这通常只能提供很少或无法提供任何关于问题真正来源的信息。如果问题是可再现的，那么可以暂时修改程序，使用一个动态类型安全视图来包装该 collection，通过这种方式可快速确定问题的来源。例如，以下声明： 

     Collection<String> c = new HashSet<String>();
可以暂时用下面的声明代替： 
     Collection<String> c = Collections.checkedCollection(
         new HashSet<String>(), String.class);
再次运行程序会造成它在将类型不正确的元素插入 collection 的地方失败，从而清楚地识别问题的来源。问题得以解决后，可以将修改后的声明转换回原来的声明。

返回的 collection 不会 将 hashCode 和 equals 操作传递给底层实现 collection，但这依赖于 Object 的 equals 和 hashCode 方法。在底层实现 collection 是一个 set 或一个列表的情况下，有必要遵守这些操作的协定。

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

参数：
c - 将返回其动态类型安全视图的 collection
type - 允许 c 持有的元素类型
返回：
指定 collection 的动态安全类型视图
从以下版本开始：
1.5

checkedSet

public static <E> Set<E> checkedSet(Set<E> s,
                                    Class<E> type)
返回指定 set 的一个动态类型安全视图。试图插入一个错误类型的元素将导致立即抛出 ClassCastException。假设在生成动态类型安全视图之前，set 不包含任何类型不正确的元素，并且所有对该 set 的后续访问都通过该视图进行，则可以 保证 该 set 不包含类型不正确的元素。

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

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

参数：
s - 将返回其动态类型安全视图的 set
type - 允许 s 持有的元素类型
返回：
指定 set 的动态安全类型视图
从以下版本开始：
1.5

checkedSortedSet

public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s,
                                                Class<E> type)
返回指定有序 set 的一个动态类型安全视图。试图插入一个错误类型的元素将导致立即抛出 ClassCastException。假设在生成动态类型安全视图之前，有序 set 不包含任何类型不正确的元素，并且所有对该有序 set 的后续访问都通过该视图进行，则可以 保证 该有序 set 不包含类型不正确的元素。

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

如果指定的有序 set 是可序列化的，则返回的有序 set 也将是可序列化的。

参数：
s - 将返回其动态类型安全视图的 set
type - 允许 s 持有的元素类型
返回：
指定有序 set 的动态安全类型视图
从以下版本开始：
1.5

checkedList

public static <E> List<E> checkedList(List<E> list,
                                      Class<E> type)
返回指定列表的一个动态类型安全视图。试图插入一个错误类型的元素将导致立即抛出 ClassCastException。假设在生成动态类型安全视图之前，列表不包含任何类型不正确的元素，并且所有对该列表的后续访问都通过该视图进行，则可以 保证 此列表不包含类型不正确的元素。

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

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

参数：
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。类似地，试图修改当前与键关联的值（无论是直接通过映射自身，还是通过一个从该映射 项集视图中获得的 Map.Entry 实例）都将导致立即抛出 ClassCastException。

假设在生成动态类型安全视图之前，映射中不包含任何类型不正确的键或值，并且所有对映射的后续访问都通过该视图（或其 collection 视图之一）进行，则可以保证 该映射不包含类型不正确的键或值。

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

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

参数：
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。类似地，试图修改当前与键关联的值（无论是直接通过映射自身，还是通过一个从该映射 项集视图中获得的 Map.Entry 实例）将导致立即抛出 ClassCastException。

假设在生成动态类型安全视图之前，映射中不包含任何类型不正确的键或值，并且所有对映射的后续访问都通过该视图（或其 collection 视图之一）进行，则可以保证 此映射不包含类型不正确的键或值。

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

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

参数：
m - 将返回其动态类型安全视图的映射
keyType - 允许 m 持有的键的类型
valueType - 允许 m 持有的值的类型
返回：
指定映射的动态类型安全视图
从以下版本开始：
1.5

emptySet

public static final <T> Set<T> emptySet()
返回空的 set（不可变的）。此 set 是可序列化的。与 like-named 字段不同，此方法是参数化的。

以下示例演示了获得空 set 的类型安全 (type-safe) 方式： 

     Set<String> s = Collections.emptySet();
实现注意事项：实现此方法不需要为每次调用创建一个单独的 Set 对象。使用此方法的开销与使用 like-named 字段相当。（与此方法不同，该字段不提供类型安全。）

从以下版本开始：
1.5
另请参见：
EMPTY_SET

emptyList

public static final <T> List<T> emptyList()
返回空的列表（不可变的）。此列表是可序列化的。

以下示例演示了获得空列表的类型安全方式： 

     List<String> s = Collections.emptyList();
实现注意事项：实现此方法不需要为每次调用创建一个单独的 List 对象。使用此方法的开销与使用 like-named 字段相当。（与此方法不同，该字段不提供类型安全。）

从以下版本开始：
1.5
另请参见：
EMPTY_LIST

emptyMap

public static final <K,V> Map<K,V> emptyMap()
返回空的映射（不可变的）。此映射是可序列化的。

以下示例演示了获得空 set 的类型安全方式： 

     Map<String, Date> s = Collections.emptyMap();
实现注意事项：实现此方法不需要为每次调用创建一个单独的 Map 对象。使用此方法的开销与使用 like-named 字段相当。（与此方法不同，该字段不提供类型安全。）

从以下版本开始：
1.5
另请参见：
EMPTY_MAP

singleton

public static <T> Set<T> singleton(T o)
返回一个只包含指定对象的不可变 set。返回的 set 是可序列化的。

参数：
o - 将存储到返回 set 中的单独对象。
返回：
一个只包含指定对象的不可变 set。

singletonList

public static <T> List<T> singletonList(T o)
返回一个只包含指定对象的不可变列表。返回的列表是可序列化的。

参数：
o - 将存储到返回列表中的单独对象。
返回：
一个只包含指定对象的不可变列表。
从以下版本开始：
1.3

singletonMap

public static <K,V> Map<K,V> singletonMap(K key,
                                          V value)
返回一个不可变的映射，它只将指定键映射到指定值。返回的映射是可序列化的。

参数：
key - 将存储到返回映射中的单独键。
value - 返回的映射将 key 映射到的值。
返回：
只包含指定键-值映射关系的不可变映射。
从以下版本开始：
1.3

nCopies

public static <T> List<T> nCopies(int n,
                                  T o)
返回由指定对象的 n 个副本组成的不可变列表。新分配的数据对象非常小（它只包含一个对该数据对象的引用）。在通过与 List.addAll 方法组合来增大列表时，此方法很有用。返回的列表是可序列化的。

参数：
n - 返回列表中的元素数。
o - 重复出现在返回列表中的元素。
返回：
由指定对象 n 个副本组成的不可变列表。
抛出：
IllegalArgumentException - 如果 n < 0。
另请参见：
List.addAll(Collection), List.addAll(int, Collection)

reverseOrder

public static <T> Comparator<T> reverseOrder()
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的 自然顺序。（自然顺序是通过对象自身的 compareTo 方法强行排序的。）此方法允许使用单个语句，以逆自然顺序对实现了 Comparable 接口的对象 collection（或数组）进行排序（或维护）。例如，假设 a 是一个字符串数组。那么： 
                Arrays.sort(a, Collections.reverseOrder());
将按照逆字典（字母）顺序对数组进行排序。

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

返回：
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的 自然顺序。
另请参见：
Comparable

reverseOrder

public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
返回一个比较器，它强行逆转指定比较器的顺序。如果指定比较器为 null，则此方法等同于 reverseOrder()（换句话说，它返回一个比较器，该比较器将强行逆转实现了 Comparable 接口的对象 collection 的 自然顺序）。

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

返回：
强行逆转指定比较器顺序的比较器。
从以下版本开始：
1.5

enumeration

public static <T> Enumeration<T> enumeration(Collection<T> c)
返回一个指定 collection 上的枚举。此方法提供与遗留 API 的互操作性，遗留 API 需要一个枚举作为输入。

参数：
c - 将返回其枚举的 collection。
返回：
指定 collection 上的一个枚举。
另请参见：
Enumeration

list

public static <T> ArrayList<T> list(Enumeration<T> e)
返回一个数组列表，它按返回顺序包含指定枚举返回的元素。此方法提供返回枚举的遗留 API 与需要 collection 的新 API 之间的互操作性。

参数：
e - 为返回的数组列表提供元素的枚举
返回：
包含指定枚举返回元素的数组列表。
从以下版本开始：
1.4
另请参见：
Enumeration, ArrayList

frequency

public static int frequency(Collection<?> c,
                            Object o)
返回指定 collection 中等于指定对象的元素数。更确切地讲，返回 collection 中满足 (o == null ? e == null : o.equals(e)) 的 e 元素的数量。

参数：
c - 在其中确定 o 出现频率的 collection
o - 将确定出现频率的对象
抛出：
NullPointerException - 如果 c 为 null
从以下版本开始：
1.5

disjoint

public static boolean disjoint(Collection<?> c1,
                               Collection<?> c2)
如果两个指定 collection 中没有相同的元素，则返回 true。

如果将此方法用在不符合 Collection 常规协定的 collection 上，则必须小心。实现可以在任一 collection 上进行迭代，测试元素是否包含在另一个 collection 中（或执行任何等效的计算）。如果任一 collection 使用了一个非标准的相等性测试（比如顺序不是与 equals 一致的 SortedSet，或者 IdentityHashMap 的键集），则两个 collection 都必须使用相同的非标准相等性测试，否则此方法的结果是不确定的。

注意，允许在两个参数中传递相同的 collection，在这种情况下，当且仅当 collection 为空时此方法返回 true。

参数：
c1 - 一个 collection
c2 - 一个 collection
抛出：
NullPointerException - 如果任一 collection 为 null
从以下版本开始：
1.5

addAll

public static <T> boolean addAll(Collection<? super T> c,
                                 T... elements)
将所有指定元素添加到指定 collection 中。可以分别指定要添加的元素，或者将它们指定为一个数组。此便捷方法的行为与 c.addAll(Arrays.asList(elements)) 的行为是相同的，但在大多数实现下，此方法运行起来可能要快得多。

在分别指定元素时，此方法提供了将少数元素添加到现有 collection 中的一个便捷方式： 

     Collections.addAll(flavors, "Peaches 'n Plutonium", "Rocky Racoon");

参数：
c - 要插入 elements 的 collection
elements - 插入 c 的元素
返回：
如果 collection 由于调用而发生更改，则返回 true
抛出：
UnsupportedOperationException - 如果 c 不支持 add 操作
NullPointerException - 如果 elements 包含一个或多个 null 值并且 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。得到的 set 与底层实现映射有相同的顺序、并发性和性能特征。事实上，此工厂方法提供了一个对应于任何 Map 实现的 Set 实现。不必在已经有一个对应 Set 实现（比如 HashMap 或 TreeMap）的 Map 实现上使用此方法。

每次在此方法返回的 set 上调用方法都将导致在底层实现映射或其 keySet 视图上调用该方法一次，并伴随一个异常。addAll 方法是作为底层实现映射上的 put 调用序列实现的。

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

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

参数：
map - 底层实现映射
返回：
受映射支持的 set
抛出：
IllegalArgumentException - 如果 map 不为空
从以下版本开始：
1.6

asLifoQueue

public static <T> Queue<T> asLifoQueue(Deque<T> deque)
以后进先出 (Lifo) Queue 的形式返回某个 Deque 的视图。方法 add 被映射到 push， remove 被映射到 pop 等等。在希望使用某一方法获取一个 Queue 并且需要它具有 Lifo 顺序时，此方法很有用。

每次在此方法返回的队列上调用方法都将导致在底层实现队列上调用该方法一次，并伴随一个异常。addAll 方法是作为底层实现队列上的 addFirst 调用序列实现的。

参数：
deque - 队列
返回：
队列
从以下版本开始：
1.6
概述  软件包   类  使用  树  已过时  索引  帮助 
JavaTM Platform
Standard Ed. 6
 上一个类   下一个类 框架    无框架    
摘要： 嵌套 | 字段 | 构造方法 | 方法 详细信息： 字段 | 构造方法 | 方法
提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

版权所有 2007 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。