Collections工具类

Collections 是 Java 集合框架中的一个工具类，位于 java.util 包中。它提供了一系列静态方法，用于操作和处理集合（如 List、Set、Map 等）。Collections 工具类的主要功能包括排序、查找、替换、同步化集合等

主要功能

Collections 工具类的主要功能可以分为以下几类

排序：对集合中的元素进行排序。
查找：在集合中查找元素。
替换：替换集合中的元素。
同步化：将非线程安全的集合转换为线程安全的集合。
不可变集合：创建不可修改的集合。
其他工具方法：如反转、填充、复制等

常用方法

排序

sort(List list)

对 List 中的元素进行自然顺序排序

要求集合中的元素必须实现 Comparable 接口

List<Integer> list = new ArrayList<>(Arrays.asList(5, 3, 8, 1));
Collections.sort(list);
System.out.println(list); // 输出: [1, 3, 5, 8]

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

使用自定义的 Comparator 对 List 中的元素进行排序

List<String> list = new ArrayList<>(Arrays.asList("apple", "banana", "cherry"));
Collections.sort(list, Comparator.reverseOrder());
System.out.println(list); // 输出: [cherry, banana, apple]

查找

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

使用二分查找法在已排序的列表中查找指定元素

List<Integer> list = new ArrayList<>(Arrays.asList(1,  3, 4, 5));
int index = Collections.binarySearch(list,  3);
System.out.println(index);  // 输出：1

填充与替换方法

fill(List<? super T> list, T obj)
- 将 List 中的所有元素替换为指定值
```
Collections.fill(list, 0); // [0, 0, 0, 0]
```
replaceAll(List list, T oldVal, T newVal)
- 将 List 中所有等于 oldVal 的元素替换为 newVal
```
Collections.replaceAll(list, 5, 10); // [1, 3, 10, 8]
```
其他常用方法
- reverse(List<?> list)，反转 List 中元素的顺序
```
Collections.reverse(list); // [8, 10, 3, 1]
```
- shuffle(List<?> list)，随机打乱 List 中元素的顺序
```
Collections.shuffle(list); // 随机顺序，如 [3, 1, 8, 10]
```
- synchronizedList(List list)将 List 转换为线程安全的集合
- synchronizedSet(Set set)
- synchronizedMap(Map<K, V> map)
```
List<Integer> syncList = Collections.synchronizedList(list);
```
- unmodifiableList(List<? extends T> list)返回一个不可修改的 List 视图
```
List<Integer> unmodifiableList = Collections.unmodifiableList(list);
// unmodifiableList.add(4); // 抛出 UnsupportedOperationException
```
- copy(List<? super T> dest, List<? extends T> src)，将 src 列表中的元素复制到 dest 列表中
  - 如果 dest 的长度小于 src，会抛出 IndexOutOfBoundsException。因此，在使用前需要确保 dest 的长度足够
  - Collections.copy 方法通过遍历 src 列表，将每个元素逐个设置到 dest 列表的对应位置
```
Collections.copy(dest, list); // dest: [1, 3, 5, 8]

//类似下列代码
for (int i = 0; i < src.size(); i++) {
    dest.set(i, src.get(i));
}
```
- max(Collection<? extends T> coll)返回集合中的最大元素（自然顺序）
- min(Collection<? extends T> coll)返回集合中的最小元素（自然顺序）
- frequency(Collection<?> c, Object o)返回集合中指定元素的出现次数
```
int freq = Collections.frequency(list, 5); // 1
```
- disjoint(Collection c1, Collection c2)
```
boolean disjoint = Collections.disjoint(list1, list2); // true 或 false
```

方法总结

1. 排序（Sorting）

sort(List<T> list)
对 List中的元素按自然顺序（升序）排序，要求元素实现 Comparable 接口。
sort(List<T> list, Comparator<? super T> c)
使用自定义的 Comparator 对List中的元素排序。

2. 查找（Searching）

binarySearch(List<? extends Comparable<? super T>> list, T key)
在已排序的 List 中使用二分查找算法查找指定元素，返回元素的索引，若未找到则返回负数。
binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
使用自定义的 Comparator 在已排序的 List中进行二分查找。
虽然列表已经是已排序的，但排序的规则可能不是自然顺序（即不是通过 Comparable 接口定义的顺序），而是通过自定义的 Comparator 定义的顺序。因此，binarySearch 方法需要知道列表的排序规则，才能正确地查找元素
自然顺序：如果列表中的元素实现了 Comparable 接口，并且列表是按照自然顺序排序的，那么可以直接使用 binarySearch(List<? extends Comparable<? super T>> list, T key) 方法
自定义顺序：如果列表是按照自定义的 Comparator 排序的，那么必须使用 binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 方法，并传递相同的 Comparator

3. 替换（Replacing）

replaceAll(List<T> list, T oldVal, T newVal)
将 List中所有等于 oldVal 的元素替换为 newVal。

4. 反转和随机化（Reversing and Shuffling）

reverse(List<?> list)
反转 List中元素的顺序。
shuffle(List<?> list)
随机打乱 List 中元素的顺序。

5. 同步化（Synchronization）

synchronizedList(List<T> list)
将 List转换为线程安全的集合。
synchronizedSet(Set<T> set)
将 Set 转换为线程安全的集合。
synchronizedMap(Map<K, V> map)
将 Map 转换为线程安全的集合。

6. 不可变集合（Unmodifiable Collections）

unmodifiableList(List<? extends T> list)
返回一个不可修改的 List 视图。
unmodifiableSet(Set<? extends T> set)
返回一个不可修改的 Set 视图。
unmodifiableMap(Map<? extends K, ? extends V> map)
返回一个不可修改的 Map 视图。

7. 其他工具方法

copy(List<? super T> dest, List<? extends T> src)
将 src 列表中的元素复制到 dest 列表中。

如果 dest 的长度小于 src，会抛出 IndexOutOfBoundsException。因此，在使用前需要确保 dest 的长度足够
fill(List<? super T> list, T obj)
将 List中的所有元素替换为指定值。
max(Collection<? extends T> coll)
返回集合中的最大元素（自然顺序）。
max(Collection<? extends T> coll, Comparator<? super T> comparator)

按照自定义比较器返回最大元素
min(Collection<? extends T> coll)
返回集合中的最小元素（自然顺序）。
frequency(Collection<?> c, Object o)
返回集合中指定元素的出现次数。
disjoint(Collection<?> c1, Collection<?> c2)
检查两个集合是否没有交集（即是否没有共同元素）。