Java 集合 - Collection 工具类

java.util.Collections 是 Java 提供的一个功能强大的工具类，专门用于处理各类集合，如 Set、List 和 Map。该工具类提供的各类静态方法为我们操作这些集合带来极大的便利。

下面是一些比较常用的 API，完整 API 请自行查阅官方文档：

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

   /*
    * addAll(Collection<? super T> c, T... elements)
    * 作用：将所有指定元素添加到指定 collection 中，用于一次性添加多个元素。
    * 参数：
    * c - 要添加元素的 collection
    * elements - 要添加到指定 collection 中的元素
    */
   List<String> list = new ArrayList<>();
   Collections.addAll(list, "张三", "李四", "王五");
   System.out.println(list); // [张三, 李四, 王五]
   

2. binarySearch(List<? extends T> list, T key)

   /*
    * binarySearch(List<? extends Comparable<? super T>> list, T key)
    * 作用：使用二分搜索法搜索指定列表，以获得指定对象的索引。
    * 参数：
    * list - 要搜索的列表,列表必须按照自然顺序进行排序
    * key - 要搜索的键
    */
   List<Integer> list2 = Arrays.asList(1, 2, 3, 4, 5);
   int index = Collections.binarySearch(list2, 3);
   System.out.println(index); // 2
   

3. max(Collection<? extends T> coll)

   /*
    * max(Collection<? extends T> coll)
    * 作用：根据元素的自然顺序，返回给定 collection 的最大元素。
    */
   List<Integer> list3 = Arrays.asList(1, 2, 3, 4, 5);
   Integer max = Collections.max(list3);
   System.out.println(max); // 5
   

4. min(Collection<? extends T> coll)

   /*
    * min(Collection<? extends T> coll)
    * 作用：根据元素的自然顺序，返回给定 collection 的最小元素。
    * 参数：coll - 要搜索的 collection
    */
   List<Integer> list4 = Arrays.asList(1, 2, 3, 4, 5);
   Integer min = Collections.min(list4);
   System.out.println(min); // 1
   

5. reverse(List<?> list)

   /*
    * reverse(List<?> list)
    * 作用：反转指定列表中元素的顺序。
    * 参数：list - 要反转其元素顺序的列表
    */
   List<Integer> list5 = Arrays.asList(1, 2, 3, 4, 5);
   Collections.reverse(list5);
   System.out.println(list5); // [5, 4, 3, 2, 1]
   

6. shuffle(List<?> list)

   /*
    * shuffle(List<?> list)
    * 作用：使用默认随机源对指定列表进行置换,类似于洗牌。
    * 参数：list - 要随机置换的列表
    */
   List<Integer> list6 = Arrays.asList(1, 2, 3, 4, 5);
   Collections.shuffle(list6);
   System.out.println(list6); // [3, 1, 5, 4, 2]
   

7. sort(List<T> list)

   /*
    * sort(List<T> list)
    * 作用：根据元素的自然顺序 对指定列表按升序进行排序。
    * 参数：list - 要排序的列表
    */
   List<Integer> list7 = Arrays.asList(5, 2, 1, 4, 3);
   Collections.sort(list7);
   System.out.println(list7); // [1, 2, 3, 4, 5]
   

8. reverseOrder()

   /*
    * reverseOrder()
    * 作用：返回一个比较器，强行逆转实现 Comparable 接口的对象 collection 的自然顺序。
    * 说明：一般配合 sert(List<T> list, Comparator<? super T> c) 方法使用。
    */
   List<Integer> list8 = Arrays.asList(5, 2, 1, 4, 3);
   Collections.sort(list8, Collections.reverseOrder());
   System.out.println(list8); // [5, 4, 3, 2, 1]
   

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

   /*
    * swap(List<?> list, int i, int j)
    * 作用：将指定列表中的两个元素进行交换。
    * 参数：
    * list - 要交换其元素的列表
    * i - 要交换的元素的索引
    * j - 要交换的元素的索引
    */
   List<Integer> list9 = Arrays.asList(1, 2, 3, 4, 5);
   Collections.swap(list9, 0, 4);
   System.out.println(list9); // [5, 2, 3, 4, 1]
   

10. frequency(Collection<?> c, Object o)

    /*
     * frequency(Collection<?> c, Object o)
     * 作用：返回指定 collection 中等于指定对象的元素数。
     * 参数：
     * c - 要搜索的 collection
     * o - 要搜索的对象
     */
    List<Integer> list10 = Arrays.asList(1, 2, 3, 4, 5, 1, 2, 3, 4);
    int frequency = Collections.frequency(list10, 1);
    System.out.println(frequency); // 2
    

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

    /*
     * copy(List<? super T> dest, List<? extends T> src)
     * 作用：将所有元素从一个列表复制到另一个列表。
     * 说明：
     * 1.如果目标列表 dest 的大小小于源列表 src 的大小，则抛出 IndexOutOfBoundsException 异常。
     * 2.如果目标列表不为空，则会将目标列表中的元素覆盖为源列表中的元素。
     * 3.如果目标列表为空，则会将源列表中的元素添加到目标列表中。
     * 参数：
     * dest - 目标列表,即要复制到的列表，它的长度必须至少等于 src.size()
     * src - 源列表，即要复制的列表
     */
    List<Integer> list11 = Arrays.asList(1, 2, 3, 4, 5);
    List<Integer> list12 = Arrays.asList(6, 7, 8, 9, 10);
    Collections.copy(list11, list12);
    System.out.println(list11); // [6, 7, 8, 9, 10]
    

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

    /*
     * fill(List<? super T> list, T obj)
     * 作用：用指定的元素替换指定列表中的所有元素。
     * 参数：
     * list - 要用指定元素替换指定列表中的所有元素的列表
     * obj - 要存储在指定列表中的元素
     */
    List<Integer> list13 = Arrays.asList(1, 2, 3, 4, 5);
    Collections.fill(list13, 0);
    System.out.println(list13); // [0, 0, 0, 0, 0]
    

13. replaceAll(List<T> list, T oldVal, T newVal)

    /*
     * replaceAll(List<T> list, T oldVal, T newVal)
     * 作用：使用另一个值替换列表中出现的所有某一指定值。
     * 参数：
     * list - 要替换其中值的列表
     * oldVal - 要替换的值
     * newVal - 替换 oldVal 的值
     */
    List<Integer> list14 = Arrays.asList(1, 2, 3, 4, 5);
    Collections.replaceAll(list14, 1, 0);
    System.out.println(list14); // [0, 2, 3, 4, 5]
    

14. synchronizedXxx()

    /*
     * synchronizedList(List<T> list)
     * synchronizedSet(Set<T> s)
     * synchronizedMap(Map<K,V> m)
     * 作用：返回由指定列表支持的同步（线程安全）列表。
     */
    List<Integer> list15 = Arrays.asList(1, 2, 3, 4, 5);
    List<Integer> synchronizedList = Collections.synchronizedList(list15);
    

15. unmodifiableXxx()

    /*
     * unmodifiableList(List<? extends T> list)
     * unmodifiableSet(Set<? extends T> s)
     * unmodifiableMap(Map<? extends K,? extends V> m)
     * 作用：返回指定列表支持的不可修改的列表视图，即该列表不能修改。
     * 说明：如果尝试修改返回的列表，则会抛出 UnsupportedOperationException 异常。
     */
    List<Integer> list16 = Arrays.asList(1, 2, 3, 4, 5);
    List<Integer> unmodifiableList = Collections.unmodifiableList(list16);