Collections

Collections 是一个用于操作 Set、List、Map 等集合的工具类，常见用途包括批量添加、排序、查找以及获取空集合。

添加

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

• 作用：将多个元素一次性添加到指定集合中
• 返回值：如果集合因本次调用发生变化，则返回 true
• 注意：底层会逐个调用集合的 add() 方法

List<String> names = new ArrayList<>();

boolean changed = Collections.addAll(names, "Tom", "Jerry", "Rose");

System.out.println(changed); // true
System.out.println(names);   // [Tom, Jerry, Rose]

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

• 作用：将源列表 src 中的元素复制到目标列表 dest
• 返回值：无
• 注意：dest 的长度必须>= src，否则会抛出 IndexOutOfBoundsException

List<String> src = Arrays.asList("Tom", "Jerry", "Rose");
List<String> dest = Arrays.asList(new Object[src.size()]);

Collections.copy(dest, src);

System.out.println(dest); // [Tom, Jerry, Rose]

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

• 作用：将列表中所有等于 oldVal 的元素替换为 newVal
• 返回值：如果列表发生变化，则返回 true

List<String> names = new ArrayList<>(Arrays.asList("Tom", "Jerry", "Tom", "Rose"));

boolean changed = Collections.replaceAll(names, "Tom", "Jack");

System.out.println(changed); // true
System.out.println(names);   // [Jack, Jerry, Jack, Rose]

排序

reverse(List<?> list)

• 作用：反转列表中元素的顺序
• 返回值：无

List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

Collections.reverse(numbers);

System.out.println(numbers); // [5, 4, 3, 2, 1]

shuffle(List<?> list)

• 作用：对列表中的元素进行随机排序
• 返回值：无
• 注意：每次运行结果通常都不同

List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

Collections.shuffle(numbers);

System.out.println(numbers); // 例如：[3, 1, 5, 4, 2]

sort(List<T> list)

• 作用：按照元素的自然顺序进行升序排序
• 返回值：无
• 注意：元素类型必须实现 Comparable 接口

List<Integer> numbers = new ArrayList<>(Arrays.asList(5, 2, 4, 1, 3));

Collections.sort(numbers);

System.out.println(numbers); // [1, 2, 3, 4, 5]

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

• 作用：按照指定比较器 c 进行排序
• 返回值：无

List<String> names = new ArrayList<>(Arrays.asList("Tom", "Jerry", "Rose", "Bob"));

Collections.sort(names, (a, b) -> b.length() - a.length());

System.out.println(names); // [Jerry, Rose, Tom, Bob]

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

• 作用：交换列表中指定下标 i 和 j 的元素
• 返回值：无

List<String> names = new ArrayList<>(Arrays.asList("Tom", "Jerry", "Rose"));

Collections.swap(names, 0, 2);

System.out.println(names); // [Rose, Jerry, Tom]

查找

max(Collection<? extends T> coll)

• 作用：按照元素自然顺序返回集合中的最大值
• 返回值：集合中的最大元素
• 注意：元素必须支持自然排序

Collection<Integer> numbers = Arrays.asList(3, 8, 2, 6);

Integer maxValue = Collections.max(numbers);

System.out.println(maxValue); // 8

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

• 作用：按照比较器规则返回集合中的最大值
• 返回值：集合中的最大元素

Collection<String> names = Arrays.asList("Tom", "Jerry", "Rose");

String maxName = Collections.max(names, Comparator.comparingInt(String::length));

System.out.println(maxName); // Jerry

min(Collection<? extends T> coll)

• 作用：按照元素自然顺序返回集合中的最小值
• 返回值：集合中的最小元素
• 注意：元素必须支持自然排序

Collection<Integer> numbers = Arrays.asList(3, 8, 2, 6);

Integer minValue = Collections.min(numbers);

System.out.println(minValue); // 2

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

• 作用：按照比较器规则返回集合中的最小值
• 返回值：集合中的最小元素

Collection<String> names = Arrays.asList("Tom", "Jerry", "Rose");

String minName = Collections.min(names, Comparator.comparingInt(String::length));

System.out.println(minName); // Tom

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

• 作用：在有序列表中使用二分查找指定元素
• 返回值：找到则返回下标，找不到则返回负数
• 注意：列表必须先按自然顺序排好序，否则结果不确定

List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 3, 5, 7, 9));

int index1 = Collections.binarySearch(numbers, 5);
int index2 = Collections.binarySearch(numbers, 4);

System.out.println(index1); // 2
System.out.println(index2); // 负数

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

• 作用：在按比较器规则排好序的列表中进行二分查找
• 返回值：找到则返回下标，找不到则返回负数
• 注意：列表必须先按比较器 c 的规则排序，否则结果不确定

List<String> names = new ArrayList<>(Arrays.asList("Bob", "Tom", "Rose", "Jerry"));
Comparator<String> comparator = Comparator.comparingInt(String::length);

Collections.sort(names, comparator);
int index = Collections.binarySearch(names, "Mike", comparator);

System.out.println(names); // [Bob, Tom, Rose, Jerry]
System.out.println(index); // 3

frequency(Collection<?> c, Object o)

• 作用：统计指定元素在集合中出现的次数
• 返回值：出现次数

Collection<String> names = Arrays.asList("Tom", "Jerry", "Tom", "Rose", "Tom");

int count = Collections.frequency(names, "Tom");

System.out.println(count); // 3

只读视图

unmodifiableXxx() 返回的是只读视图，不能直接通过返回结果执行添加、删除、修改操作，否则会抛出 UnsupportedOperationException。

我们可以通过修改集合间接修改只读视图，如果原集合内容发生变化，只读视图中的内容也会跟着变化

unmodifiableCollection(Collection<? extends T> c)

• 作用：返回指定集合的不可修改视图
• 返回值：只读 Collection

Collection<String> source = new ArrayList<>(Arrays.asList("Tom", "Jerry"));
Collection<String> readOnly = Collections.unmodifiableCollection(source);

System.out.println(readOnly); // [Tom, Jerry]

source.add("Rose");
System.out.println(readOnly); // [Tom, Jerry, Rose]

unmodifiableList(List<? extends T> list)

• 作用：返回指定列表的不可修改视图
• 返回值：只读 List

List<String> names = new ArrayList<>(Arrays.asList("Tom", "Jerry"));
List<String> readOnlyList = Collections.unmodifiableList(names);

System.out.println(readOnlyList.get(0)); // Tom
System.out.println(readOnlyList);        // [Tom, Jerry]

// readOnlyList.add("Rose"); // 运行时会抛出 UnsupportedOperationException

unmodifiableSet(Set<? extends T> s)

• 作用：返回指定集合的不可修改 Set 视图
• 返回值：只读 Set

Set<String> cities = new HashSet<>(Arrays.asList("Beijing", "Shanghai"));
Set<String> readOnlySet = Collections.unmodifiableSet(cities);

System.out.println(readOnlySet); // [Beijing, Shanghai]

// readOnlySet.remove("Beijing"); // 运行时会抛出 UnsupportedOperationException

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

• 作用：返回指定映射的不可修改视图
• 返回值：只读 Map

Map<String, Integer> scores = new HashMap<>();
scores.put("Tom", 95);
scores.put("Jerry", 88);

Map<String, Integer> readOnlyMap = Collections.unmodifiableMap(scores);

System.out.println(readOnlyMap);          // {Tom=95, Jerry=88}
System.out.println(readOnlyMap.get("Tom")); // 95

// readOnlyMap.put("Rose", 100); // 运行时会抛出 UnsupportedOperationException

空集合

emptyList()

• 作用：返回一个不可变的空 List
• 返回值：空列表

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

System.out.println(list);         // []
System.out.println(list.size());  // 0

emptySet()

• 作用：返回一个不可变的空 Set
• 返回值：空Set

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

System.out.println(set);         // []
System.out.println(set.isEmpty()); // true

emptyMap()

• 作用：返回一个不可变的空 Map
• 返回值：空Map

Map<String, Integer> map = Collections.emptyMap();

System.out.println(map);          // {}
System.out.println(map.isEmpty()); // true