Collections

EMPTY_LIST

List EMPTY_LIST

空列表（不可变）。 这个列表是可序列化的。

EMPTY_MAP

Map EMPTY_MAP

空映射（不可变）。 这张地图是可序列化的。

EMPTY_SET

Set EMPTY_SET

空集（不可变）。 这个集合是可序列化的。

addAll

boolean addAll (Collection<? super T> c, 
                T... elements)

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

当单独指定元素时，此方法提供了向现有集合添加少量元素的便捷方法：

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

asLifoQueue

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

返回Deque作为Deque先出（ Queue ） Queue 。 方法add被映射到push，remove映射到pop等。 如果您想使用需要Queue的方法，但您需要Lifo排序，此视图可能很有用。

对于由此方法返回的队列上的每个方法调用，都会导致在后备双端队列上调用一个方法，但有一个例外。 addAll方法是作为支持deque的一系列addFirst调用实现的。

binarySearch

int binarySearch (List<? extends T> list, 
                T key, 
                Comparator<? super T> c)

使用二进制搜索算法在指定列表中搜索指定对象。 在进行此呼叫之前，必须根据指定的比较器（如sort(List, Comparator)方法）将列表按升序排序。 如果没有排序，结果是不确定的。 如果列表包含与指定对象相同的多个元素，则不能保证会找到哪一个元素。

此方法在log（n）时间内运行“随机访问”列表（提供接近恒定时间的位置访问）。 如果指定列表未实现RandomAccess接口且较大，则此方法将执行基于迭代器的二进制搜索，以执行O（n）链接遍历和O（log n）元素比较。

binarySearch

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

使用二进制搜索算法在指定列表中搜索指定对象。 该列表必须根据被按升序排列natural ordering元素（如由sort(List)方法）之前使该呼叫。 如果没有排序，结果是不确定的。 如果列表包含与指定对象相同的多个元素，则不能保证会找到哪一个元素。

此方法在log（n）时间内运行“随机访问”列表（提供接近恒定时间的位置访问）。 如果指定的列表未实现RandomAccess接口并且很大，则此方法将执行基于迭代器的二进制搜索，该搜索执行O（n）链接遍历和O（log n）元素比较。

checkedCollection

Collection<E> checkedCollection (Collection<E> c, 
                Class<E> type)

返回指定集合的动态类型安全视图。 任何尝试插入错误类型的元素将立即导致ClassCastException 。 假设集合在生成动态类型安全视图之前不包含错误类型的元素，并且对集合的所有后续访问均通过视图进行，则确保该集合不能包含错误类型的元素。

该语言中的泛型机制提供了编译时（静态）类型检查，但可以用未经检查的强制转换来打败此机制。 通常这不是问题，因为编译器在所有这些未经检查的操作上发出警告。 然而，有些时候，静态类型检查本身是不够的。 例如，假设一个集合被传递给第三方库，并且必须通过插入错误类型的元素来避免库代码破坏集合。

动态类型安全视图的另一个用途是调试。 假设一个程序失败并显示ClassCastException ，表明一个错误类型的元素被放入参数化集合中。 不幸的是，在插入错误元素后的任何时候都可能发生异常，所以它通常很少或根本没有提供有关问题真正根源的信息。 如果问题是可重现的，可以通过临时修改程序以动态键入安全视图来包装集合，从而快速确定其来源。 例如，这个声明：

 Collection<String> c = new HashSet<>();
 

 Collection<String> c = Collections.checkedCollection(
         new HashSet<>(), String.class);
 

返回的集合不将hashCode并传递给底层集合等于操作，而是依赖于Object的equals和hashCode方法。 在后备集合是集合或列表的情况下，这对于保留这些操作的合约是必要的。

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

由于 null被认为是任何引用类型的值，所以只要后备集合有效，返回的集合就允许插入空元素。

checkedList

List<E> checkedList (List<E> list, 
                Class<E> type)

返回指定列表的动态类型安全视图。 任何尝试插入错误类型的元素将立即导致ClassCastException 。 假设在生成动态类型安全视图之前，列表中不包含错误类型的元素，并且所有后续对列表的访问均通过视图进行，则确保该列表不能包含错误类型的元素。

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

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

由于 null被认为是任何引用类型的值，因此返回的列表允许在支持列表执行时插入空元素。

checkedMap

Map<K, V> checkedMap (Map<K, V> m, 
                Class<K> keyType, 
                Class<V> valueType)

返回指定映射的动态类型安全视图。 任何尝试插入其键或值具有错误类型的映射都将立即导致ClassCastException 。 类似地，任何试图修改当前值与按键相关联将导致立即ClassCastException ，是否修改是通过地图本身直接试图，或通过Map.Entry从地图的获得实例entry set图。

假设地图在生成动态类型安全视图之前不包含错误键入的键或值，并且所有后续对地图的访问均通过视图（或其集合视图之一）进行，则可以 保证地图不能包含错误键入的键或值。

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

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

由于 null被认为是任何引用类型的值，因此返回的映射允许在后台映射执行时插入空键或值。

checkedSet

Set<E> checkedSet (Set<E> s, 
                Class<E> type)

返回指定集合的动态类型安全视图。 任何尝试插入错误类型的元素将立即导致ClassCastException 。 假设一个集合在生成一个动态类型安全视图之前不包含错误类型的元素，并且所有对该集合的后续访问都是通过视图进行的，则保证该集合不能包含错误类型的元素。

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

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

由于 null被认为是任何引用类型的值，因此返回的集合允许在后台集合执行时插入空元素。

checkedSortedMap

SortedMap<K, V> checkedSortedMap (SortedMap<K, V> m, 
                Class<K> keyType, 
                Class<V> valueType)

返回指定排序映射的动态类型安全视图。 任何尝试插入其键或值具有错误类型的映射都将立即导致ClassCastException 。 同样，任何尝试修改当前与某个关键字相关联的值都将立即导致ClassCastException ，无论是直接通过地图本身尝试修改还是通过从地图的entry set视图获取的Map.Entry实例。

假设地图在生成动态类型安全视图之前不包含错误键入的键或值，并且所有后续对地图的访问均通过视图（或其集合视图之一）进行，则可以 保证地图不能包含错误键入的键或值。

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

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

由于 null被认为是任何引用类型的值，因此返回的映射允许在后台映射执行时插入空值键或值。

checkedSortedSet

SortedSet<E> checkedSortedSet (SortedSet<E> s, 
                Class<E> type)

返回指定的有序集合的动态类型安全视图。 任何尝试插入错误类型的元素将立即导致ClassCastException 。 假定一个有序集合在动态类型安全视图生成之前不包含错误类型的元素，并且对有序集合的所有后续访问均通过视图进行，则确保排序后的集合不能包含错误类型的元素。

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

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

由于 null被认为是任何引用类型的值，所以返回的排序集允许插入空元素，只要支持排序集合。

copy

void copy (List<? super T> dest, 
                List<? extends T> src)

将一个列表中的所有元素复制到另一个列表中。 操作之后，目标列表中每个复制元素的索引将与源列表中的索引相同。 目的地列表必须至少与源列表一样长。 如果它更长，目标列表中的其余元素不受影响。

此方法在线性时间内运行。

disjoint

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

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

如果此方法用于不符合Collection的一般合同的馆藏，则必须Collection 。 实现可以选择迭代收集和测试其他集合中的遏制（或执行任何等效计算）。 如果两个集合使用非标准相等性测试（如SortedSet的排序与equals不相容 ，或者IdentityHashMap的键集合），则两个集合都必须使用相同的非标准相等性测试，否则此方法的结果未定义。

在使用对可能包含的元素有限制的集合时，还必须小心。 允许集合实现为涉及他们认为不合格的元素的任何操作抛出异常。 为了绝对安全，指定集合应仅包含适用于这两个集合的元素。

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

emptyEnumeration

Enumeration<T> emptyEnumeration ()

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

• hasMoreElements always returns false.
• nextElement always throws NoSuchElementException.

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

emptyIterator

Iterator<T> emptyIterator ()

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

• hasNext always returns false.
• next always throws NoSuchElementException.
• remove always throws IllegalStateException.

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

emptyList

List<T> emptyList ()

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

此示例说明了获取空列表的类型安全方法：

     List<String> s = Collections.emptyList();
 

emptyListIterator

ListIterator<T> emptyListIterator ()

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

• hasNext and hasPrevious always return false.
• next and previous always throw NoSuchElementException.
• remove and set always throw IllegalStateException.
• add always throws UnsupportedOperationException.
• nextIndex always returns 0.
• previousIndex always returns -1.

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

emptyMap

Map<K, V> emptyMap ()

返回空映射（不可变）。 这张地图是可序列化的。

此示例说明了获取空映射的类型安全方法：

     Map<String, Date> s = Collections.emptyMap();
 

emptySet

Set<T> emptySet ()

返回一个空集（不可变）。 这个集合是可序列化的。 与类似名称的字段不同，此方法被参数化。

此示例说明了获取空集的类型安全方法：

     Set<String> s = Collections.emptySet();
 

enumeration

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

返回指定集合上的枚举。 这提供了与需要枚举作为输入的传统API的互操作性。

fill

void fill (List<? super T> list, 
                T obj)

用指定的元素替换指定列表中的所有元素。

此方法在线性时间内运行。

frequency

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

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

indexOfSubList

int indexOfSubList (List<?> source, 
                List<?> target)

返回指定源列表中第一次出现指定目标列表的起始位置，如果不存在，则返回-1。 更正式地说，返回最低索引i，例如source.subList(i, i+target.size()).equals(target) ，如果没有这样的索引，则返回-1。 （如果target.size() > source.size()返回-1）

该实施方式使用扫描源列表的“强力”技术，依次在每个位置寻找与目标的匹配。

lastIndexOfSubList

int lastIndexOfSubList (List<?> source, 
                List<?> target)

返回指定源列表中最后一次出现的指定目标列表的起始位置，如果没有此类出现，则返回-1。 更正式地说，返回i的最高索引，例如source.subList(i, i+target.size()).equals(target) ，如果没有这样的索引，则返回-1。 （如果是target.size() > source.size()返回-1）

该实现使用迭代源列表的“强力”技术，依次在每个位置寻找与目标的匹配。

list

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

返回一个数组列表，其中包含由枚举返回的指定枚举返回的元素。 此方法提供了返回枚举的旧API和需要集合的新API之间的互操作性。

max

T max (Collection<? extends T> coll, 
                Comparator<? super T> comp)

根据指定比较器引发的顺序，返回给定集合的最大元素。 集合中的所有元素必须通过指定的比较器相互比较（即， comp.compare(e1, e2)不得为集合中的任何元素e1和e2投掷ClassCastException ）。

此方法遍历整个集合，因此它需要的时间与集合的大小成比例。

max

T max (Collection<? extends T> coll)

根据元素的自然顺序返回给定集合的最大元素。 集合中的所有元素都必须实现Comparable接口。 此外，集合中的所有元素都必须相互可比 （即， e1.compareTo(e2)不得为集合中的任何元素e1和e2投掷ClassCastException ）。

此方法遍历整个集合，因此它需要的时间与集合的大小成比例。

min

T min (Collection<? extends T> coll)

根据元素的自然顺序返回给定集合的最小元素。 集合中的所有元素都必须实现Comparable接口。 此外，集合中的所有元素必须相互可比 （即， e1.compareTo(e2)不得为集合中的任何元素e1和e2抛出ClassCastException ）。

此方法遍历整个集合，因此它需要的时间与集合的大小成比例。

min

T min (Collection<? extends T> coll, 
                Comparator<? super T> comp)

根据指定比较器引发的顺序返回给定集合的最小元素。 集合中的所有元素必须可以通过指定的比较器进行相互比较（也就是说， comp.compare(e1, e2)不得为集合中的任何元素e1和e2投掷ClassCastException ）。

此方法遍历整个集合，因此它需要的时间与集合的大小成比例。

nCopies

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

返回由指定对象的n份副本组成的不可变列表。 新分配的数据对象很小（它包含对数据对象的单个引用）。 此方法与List.addAll方法结合使用以增加列表很有用。 返回的列表是可序列化的。

newSetFromMap

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>());
 

replaceAll

boolean replaceAll (List<T> list, 
                T oldVal, 
                T newVal)

用另一个替换列表中所有出现的指定值。 更正式地，替换newVal每个元素e在list这样(oldVal==null ? e==null : oldVal.equals(e))。 （此方法对列表的大小没有影响。）

reverse

void reverse (List<?> list)

颠倒指定列表中元素的顺序。

此方法在线性时间内运行。

reverseOrder

Comparator<T> reverseOrder ()

返回一个比较器， Comparable实现Comparable接口的对象集合施加自然排序的反向。 （自然顺序是由物体本身的确定的顺序对compareTo方法）。这使得能够简单成语用于分拣（或维持）实现该对象的集合（或阵列） Comparable在反向自然顺序接口。 例如，假设a是一个字符串数组。 然后：

          Arrays.sort(a, Collections.reverseOrder());
 

返回的比较器是可串行化的。

reverseOrder

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

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

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

rotate

void rotate (List<?> list, 
                int distance)

按指定的距离旋转指定列表中的元素。 调用此方法后，在索引i的元件将是元件预先在索引(i - distance) list.size() MOD，用于0 list.size()-1和（含）之间的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);
 

     Collections.rotate(l.subList(1, 4), -1);
 

要向前移动多个元素，请增加旋转距离的绝对值。 要向后移动元素，请使用正移位距离。

如果指定的列表很小或者实现了RandomAccess接口，则该实现将第一个元素交换到它应该去的位置，然后重复地将位移元素交换到它应该去的位置，直到将位移元素交换到第一个元素。 如有必要，在第二个和后续元素上重复该过程，直到旋转完成。 如果指定的列表较大并且未实现RandomAccess接口，则此实现将列表分为索引-distance mod size周围的两个子列表视图。 然后在每个子列表视图上调用reverse(List)方法，最后在整个列表中调用它。 有关这两种算法的更完整描述，请参阅Jon Bentley 编程珍珠的第2.3节（Addison-Wesley，1986）。

shuffle

void shuffle (List<?> list, 
                Random rnd)

使用指定的随机来源随机排列指定的列表。 假设随机性的来源是公平的，所有置换都以相等的可能性发生。

该实现向后遍历列表，从最后一个元素到第二个元素，将随机选择的元素重复交换到“当前位置”。 元素是从列表中从第一个元素到当前位置（包含）的部分随机选择的。

此方法在线性时间内运行。 如果指定的列表没有实现RandomAccess接口并且很大，那么这个实现将指定的列表转储到一个数组中，然后将混洗数组转储回列表中。 这可以避免由于对“顺序访问”列表进行混洗而导致的二次行为。

shuffle

void shuffle (List<?> list)

使用默认的随机源随机排列指定的列表。 所有排列发生的可能性几乎相等。

在前面的描述中使用了“近似”对冲，因为默认的随机源只是近似独立选择比特的无偏差源。 如果它是随机选择比特的完美来源，则该算法将选择具有完全一致性的排列。

该实现向后遍历列表，从最后一个元素到第二个元素，将随机选择的元素重复交换到“当前位置”。 元素是从列表中从第一个元素到当前位置（包含）的部分随机选择的。

此方法在线性时间内运行。 如果指定的列表没有实现RandomAccess接口并且很大，则此实现将指定列表转储到数组中，然后将混洗数组转储回列表中。 这可以避免由于对“顺序访问”列表进行混洗而导致的二次行为。

singleton

Set<E> singleton (E o)

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

singletonList

List<E> singletonList (E o)

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

singletonMap

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

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

sort

void sort (List<T> list)

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

这种保证是 稳定的 ：相同的元素不会因排序而重新排序。

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

实现注意事项：这个实现是一个稳定的自适应迭代mergesort，当输入数组部分排序时，需要远远少于n lg（n）的比较，同时在输入数组是随机排序时提供传统mergesort的性能。 如果输入数组几乎排序，则实现需要大约n次比较。 临时存储要求从几乎排序的输入数组的小常量到随机排序的输入数组的n / 2个对象引用。

该实现在其输入数组中具有升序和降序的相等优势，并且可以利用相同输入数组的不同部分中的升序和降序。 它非常适合合并两个或多个有序数组：简单地连接数组并对结果数组进行排序。

该实现改编自Tim Peters的Python列表（ TimSort ）。 它使用Peter McIlroy在“第四届年度ACM-SIAM离散算法研讨会论文集”第467-474页（1993年1月）中的“乐观排序和信息理论复杂性”的技术。

该实现将指定的列表转储到数组中，对数组进行排序，然后遍历列表，以重置数组中相应位置的每个元素。 这样可以避免尝试对链表进行排序而导致的n ² log（n）性能。

sort

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

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

这种保证是 稳定的 ：相同的元素不会因排序而重新排序。

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

实现注意事项：这个实现是一个稳定的自适应迭代mergesort，当输入数组部分排序时，需要远远少于n lg（n）的比较，同时在输入数组是随机排序时提供传统mergesort的性能。 如果输入数组几乎排序，则实现需要大约n次比较。 临时存储要求从几乎排序的输入数组的小常量到随机排序的输入数组的n / 2个对象引用。

该实现在其输入数组中具有升序和降序的相等优势，并且可以利用相同输入数组的不同部分中的升序和降序。 它非常适合合并两个或多个有序数组：简单地连接数组并对结果数组进行排序。

这个实现是根据Tim Peters的Python列表排序（ TimSort ）改编的。 它使用Peter McIlroy在“第四届年度ACM-SIAM离散算法研讨会论文集”第467-474页（1993年1月）中的“乐观排序和信息理论复杂性”的技术。

该实现将指定的列表转储到数组中，对数组进行排序，然后遍历列表，以重置数组中相应位置的每个元素。 这样可以避免尝试对链表进行排序而导致的n ² log（n）性能。

swap

void swap (List<?> list, 
                int i, 
                int j)

交换指定列表中指定位置的元素。 （如果指定的位置相同，则调用此方法将使列表保持不变。）

synchronizedCollection

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方法。 在后备集合是集合或列表的情况下，这对于保留这些操作的合约是必要的。

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

synchronizedList

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());
  }
 

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

synchronizedMap

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

返回由指定映射支持的同步（线程安全）映射。 为了保证串行访问，通过返回的映射完成对备份映射的所有访问是非常重要的。

在迭代任何集合视图时，用户必须手动在返回的地图上进行同步：

  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());
  }
 

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

synchronizedSet

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

返回由指定集支持的同步（线程安全）集。 为了保证串行访问，通过返回集完成对后台集的所有访问是非常重要的。

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

  Set s = Collections.synchronizedSet(new HashSet());
      ...
  synchronized (s) {
      Iterator i = s.iterator(); // Must be in the synchronized block
      while (i.hasNext())
          foo(i.next());
  }
 

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

synchronizedSortedMap

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());
  }
 

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

synchronizedSortedSet

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

返回由指定的排序集支持的同步（线程安全）排序集。 为了保证串行访问，通过返回的排序集（或其视图）完成对后备有序集的所有访问是非常重要的。

至关重要的是，用户迭代，或任何其 subSet，headSet，或 tailSet意见时，在返回的有序集合手动同步。

  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());
  }
 

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

unmodifiableCollection

Collection<T> unmodifiableCollection (Collection<? extends T> c)

返回指定集合的不可修改视图。 该方法允许模块为用户提供对内部集合的“只读”访问权限。 对返回的集合的“查询”操作对指定的集合进行“读取”操作，并尝试修改返回的集合（无论是直接还是通过其迭代器）都会导致UnsupportedOperationException 。

返回的集合不将hashCode并传递给底层集合等于操作，而是依赖于Object的equals和hashCode种方法。 在后备集合是集合或列表的情况下，这对于保留这些操作的合约是必要的。

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

unmodifiableList

List<T> unmodifiableList (List<? extends T> list)

返回指定列表的不可修改视图。 此方法允许模块为用户提供对内部列表的“只读”访问权限。 将返回列表上的查询操作“读取”到指定列表中，并尝试修改返回的列表，无论是直接还是通过其迭代器，都会导致UnsupportedOperationException 。

如果指定的列表是可序列化的，则返回的列表将是可序列化的。 同样，如果指定的列表有，则返回的列表将执行RandomAccess 。

unmodifiableMap

Map<K, V> unmodifiableMap (Map<? extends K, ? extends V> m)

返回指定地图的不可修改视图。 该方法允许模块为用户提供对内部地图的“只读”访问。 对返回地图上的“查询”操作对指定地图进行“读取”操作，并试图修改返回的地图（无论是直接还是通过其集合视图），都会导致UnsupportedOperationException 。

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

unmodifiableSet

Set<T> unmodifiableSet (Set<? extends T> s)

返回指定集的不可修改视图。 该方法允许模块为用户提供对内部集合的“只读”访问权限。 将返回集上的查询操作“读取”到指定的集合，并尝试修改返回的集合，无论是直接还是通过迭代器，都会导致UnsupportedOperationException 。

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

unmodifiableSortedMap

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

返回指定排序映射的不可修改视图。 该方法允许模块为用户提供对内部排序地图的“只读”访问。 对返回的排序映射进行查询操作“读取”到指定的排序映射。 试图修改返回的有序映射，无论是直接的，通过其收集的意见，或通过其subMap，headMap，或tailMap意见，导致UnsupportedOperationException。

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

unmodifiableSortedSet

SortedSet<T> unmodifiableSortedSet (SortedSet<T> s)

返回指定排序集的不可修改视图。 此方法允许模块为用户提供对内部排序集的“只读”访问权限。 对返回的有序集进行查询操作“读取”到指定的有序集。 试图修改返回的有序集合，无论是直接的，通过其迭代器，或通过其subSet，headSet，或tailSet意见，导致UnsupportedOperationException。

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