方法 描述
addAll(Collection<? super T> c, T... elements) 向集合中添加多个元素
sort(List<T> list) 对列表进行自然顺序排序（需要元素实现 Comparable 接口）
sort(List<T> list, Comparator<? super T> c) 使用指定的比较器对列表进行排序
reverse(List<?> list) 反转列表中的元素顺序
shuffle(List<?> list) 对列表元素进行随机排列
max(Collection<? extends T> coll) 返回集合中的最大元素（自然顺序）
max(Collection<? extends T> coll, Comparator<? super T> comp) 根据比较器返回集合中的最大元素
min(Collection<? extends T> coll) 返回集合中的最小元素（自然顺序）
min(Collection<? extends T> coll, Comparator<? super T> comp) 根据比较器返回集合中的最小元素
frequency(Collection<?> c, Object o) 返回指定元素在集合中的出现次数
binarySearch(List<? extends T> list, T key) 二分搜索（列表必须是排序状态）
copy(List<? super T> dest, List<? extends T> src) 将源列表的元素复制到目标列表
fill(List<? super T> list, T obj) 将列表的所有元素替换为指定元素
nCopies(int n, T obj) 返回包含指定对象的不可变列表，包含 n 个副本
replaceAll(List<T> list, T oldVal, T newVal) 替换列表中所有指定元素
swap(List<?> list, int i, int j) 交换列表中两个索引位置的元素
unmodifiableList(List<? extends T> list) 返回一个不可修改的列表视图 
public static void main(String[] args) {  
    List<Integer> list = new ArrayList<>(Arrays.asList(5, 3, 8, 1, 2));  
  
    // 1. addAll(Collection<? super T> c, T... elements) - 添加多个元素  
    Collections.addAll(list, 9, 6, 4);  
    System.out.println("After addAll: " + list);  
  
    // 2. sort(List<T> list) - 自然顺序排序  
    Collections.sort(list);  
    System.out.println("After sort: " + list);  
  
    // 3. sort(List<T> list, Comparator<? super T> c) - 自定义排序  
    Collections.sort(list, Comparator.reverseOrder());  
    System.out.println("After custom sort: " + list);  
  
    // 4. reverse(List<?> list) - 反转列表  
    Collections.reverse(list);  
    System.out.println("After reverse: " + list);  
  
    // 5. shuffle(List<?> list) - 随机打乱  
    Collections.shuffle(list);  
    System.out.println("After shuffle: " + list);  
  
    // 6. max(Collection<? extends T> coll) - 获取最大值  
    System.out.println("Max element: " + Collections.max(list));  
  
    // 7. min(Collection<? extends T> coll) - 获取最小值  
    System.out.println("Min element: " + Collections.min(list));  
  
    // 8. frequency(Collection<?> c, Object o) - 统计频率  
    System.out.println("Frequency of 4: " + Collections.frequency(list, 4));  
  
    // 9. binarySearch(List<? extends T> list, T key) - 二分查找  
    Collections.sort(list); // 需要先排序  
    System.out.println("Index of 4 (binarySearch): " + Collections.binarySearch(list, 4));  
  
    // 10. copy(List<? super T> dest, List<? extends T> src) - 复制列表  
    List<Integer> dest = new ArrayList<>(Arrays.asList(new Integer[list.size()]));  
    Collections.copy(dest, list);  
    System.out.println("Copied list: " + dest);  
  
    // 11. fill(List<? super T> list, T obj) - 填充元素  
    Collections.fill(dest, 0);  
    System.out.println("After fill with 0: " + dest);  
  
    // 12. replaceAll(List<T> list, T oldVal, T newVal) - 替换元素  
    Collections.replaceAll(list, 4, 10);  
    System.out.println("After replace 4 with 10: " + list);  
  
    // 13. swap(List<?> list, int i, int j) - 交换元素  
    Collections.swap(list, 0, list.size() - 1);  
    System.out.println("After swap: " + list);  
  
    // 14. unmodifiableList(List<? extends T> list) - 不可修改的列表  
    List<Integer> unmodifiableList = Collections.unmodifiableList(list);  
    System.out.println("Unmodifiable list: " + unmodifiableList);  
    // unmodifiableList.add(100); // 会抛出 UnsupportedOperationException}