概觀  軟體套件   類別  使用  階層樹  已過時  索引  說明 
JavaTM 2 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 2 Platform
Standard Ed. 6
 上一個類別   下一個類別 框架    無框架    
摘要： 巢狀 | 欄位 | 建構子 | 方法 詳細資訊： 欄位 | 建構子 | 方法
提交錯誤或意見

版權所有 2008 Sun Microsystems, Inc. 保留所有權利。請遵守GNU General Public License, version 2 only。