模块  java.base
软件包  java.util

Class Collections

  • public class Collectionsextends Object
    此类仅包含对集合进行操作或返回集合的静态方法。 它包含对集合进行操作的多态算法，“包装器”，它返回由指定集合支持的新集合，以及其他一些可能性和结束。

    如果提供给它们的集合或类对象为null，则此类的方法都抛出NullPointerException 。

    包含在这个类中的多态算法的文档通常包括执行情况的简短描述。 这些描述应被视为实施说明 ，而不是规范的一部分 。 只要遵守规范本身，实现者就可以随意替换其他算法。 （例如， sort使用的算法不一定是mergesort，但它必须是稳定的 。）

    如果集合不支持适当的变异原语（例如set方法），则此类中包含的“破坏性”算法（即修改它们运行的集合的算法）被指定为抛出UnsupportedOperationException 。 如果调用对集合没有影响，则这些算法可能（但不是必须）抛出此异常。 例如，在已经排序的不可修改列表上调用sort方法可能会也可能不会抛出UnsupportedOperationException 。

    本课程是Java Collections Framework的成员。

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

    • 字段详细信息

      • 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) mod list.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()
        返回没有元素的迭代器。 更确切地说，

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

        参数类型
        T - 迭代器中的元素类型（如果有）
        结果
        一个空的迭代器
        从以下版本开始：
        1.7

      • emptyEnumeration

        public static <T> Enumeration<T> emptyEnumeration()
        返回没有元素的枚举。 更确切地说，

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

        参数类型
        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

        @SafeVarargspublic 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