Collections 工具类常用方法全解

import java.util.Collections;

① sort(List list)

用法： 对列表进行升序排序（自然排序）。列表元素必须实现 Comparable 接口。

List<Integer> list = new ArrayList<>();
list.add(3);
list.add(1);
list.add(4);
list.add(2);
Collections.sort(list);
// 列表状态: [1, 2, 3, 4]
System.out.println(list); // [1, 2, 3, 4]

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

用法： 根据指定比较器对列表进行排序。

List<String> list = new ArrayList<>();
list.add("banana");
list.add("apple");
list.add("cherry");
Collections.sort(list, Comparator.reverseOrder());
// 列表状态: [cherry, banana, apple]（降序）
System.out.println(list); // [cherry, banana, apple]

// 按字符串长度排序
Collections.sort(list, (a, b) -> a.length() – b.length());
// 列表状态: [apple, banana, cherry]（按长度升序）
System.out.println(list); // [apple, banana, cherry]

③ reverse(List<?> list)

用法： 反转列表中元素的顺序。

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Collections.reverse(list);
// 列表状态: [4, 3, 2, 1]
System.out.println(list); // [4, 3, 2, 1]

④ shuffle(List<?> list)

用法： 随机打乱列表中元素的顺序（使用默认随机源）。

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Collections.shuffle(list);
// 列表状态: 每次结果不同，如 [2, 4, 1, 3]
System.out.println(list); // 可能是 [2, 4, 1, 3]

⑤ shuffle(List<?> list, Random rnd)

用法： 使用指定的随机源随机打乱列表。

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Random random = new Random(123); // 固定种子，每次结果相同
Collections.shuffle(list, random);
// 列表状态: [3, 4, 2, 1]（固定种子保证可重现）
System.out.println(list); // [3, 4, 2, 1]

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

用法： 交换列表中指定位置的两个元素。

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Collections.swap(list, 0, 3);
// 列表状态: [4, 2, 3, 1]（交换索引0和3）
System.out.println(list); // [4, 2, 3, 1]

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

用法： 使用二分查找法在已排序的列表中查找指定元素。返回索引，若找不到返回 -(插入点) – 1。

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(3);
list.add(5);
list.add(7);
list.add(9);
// 必须提前排序！
Collections.sort(list); // [1, 3, 5, 7, 9]

int index = Collections.binarySearch(list, 5);
// 返回 2（索引位置）
System.out.println(index); // 2

int notFound = Collections.binarySearch(list, 6);
// 返回 -4（插入点索引3，所以 -(3) – 1 = -4）
System.out.println(notFound); // -4

⑧ max(Collection<? extends T> coll)

用法： 返回集合中的最大元素（根据自然排序）。

List<Integer> list = new ArrayList<>();
list.add(3);
list.add(7);
list.add(1);
list.add(9);
Integer max = Collections.max(list);
// 返回 9
System.out.println(max); // 9

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

用法： 根据指定比较器返回集合中的最大元素。

List<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add("cherry");
// 按字符串长度找最大
String max = Collections.max(list, (a, b) -> a.length() – b.length());
// 返回 "banana" 或 "cherry"（长度都是6，返回第一个）
System.out.println(max); // banana

⑩ min(Collection<? extends T> coll)

用法： 返回集合中的最小元素（根据自然排序）。

List<Integer> list = new ArrayList<>();
list.add(3);
list.add(7);
list.add(1);
list.add(9);
Integer min = Collections.min(list);
// 返回 1
System.out.println(min); // 1

⑪ frequency(Collection<?> c, Object o)

用法： 返回指定元素在集合中出现的次数。

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(1);
list.add(3);
list.add(1);
int count = Collections.frequency(list, 1);
// 返回 3（1出现了3次）
System.out.println(count); // 3

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

用法： 用指定元素替换列表中的所有元素。

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
Collections.fill(list, 99);
// 列表状态: [99, 99, 99]
System.out.println(list); // [99, 99, 99]

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

用法： 将源列表中的所有元素复制到目标列表。目标列表长度必须 >= 源列表。

List<Integer> src = new ArrayList<>();
src.add(1);
src.add(2);
src.add(3);

List<Integer> dest = new ArrayList<>();
dest.add(0);
dest.add(0);
dest.add(0);
dest.add(0);
dest.add(0);

Collections.copy(dest, src);
// 列表状态: [1, 2, 3, 0, 0]（前3个被替换）
System.out.println(dest); // [1, 2, 3, 0, 0]

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

用法： 将所有指定元素添加到集合中。

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
Collections.addAll(list, 3, 4, 5);
// 列表状态: [1, 2, 3, 4, 5]
System.out.println(list); // [1, 2, 3, 4, 5]

⑮ replaceAll(List list, T oldVal, T newVal)

用法： 将列表中所有出现的旧值替换为新值。

List<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add("apple");
list.add("cherry");
Collections.replaceAll(list, "apple", "orange");
// 列表状态: [orange, banana, orange, cherry]
System.out.println(list); // [orange, banana, orange, cherry]

⑯ rotate(List<?> list, int distance)

用法： 将列表中的元素循环移动指定距离。正数向右移，负数向左移。

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);

Collections.rotate(list, 2); // 向右移2位
// 列表状态: [4, 5, 1, 2, 3]
System.out.println(list); // [4, 5, 1, 2, 3]

Collections.rotate(list, -1); // 向左移1位
// 列表状态: [5, 1, 2, 3, 4]
System.out.println(list); // [5, 1, 2, 3, 4]

⑰ disjoint(Collection c1, Collection c2)

用法： 判断两个集合是否没有交集。没有交集返回 true，有交集返回 false。

List<Integer> list1 = new ArrayList<>();
list1.add(1);
list1.add(2);
list1.add(3);

List<Integer> list2 = new ArrayList<>();
list2.add(4);
list2.add(5);
list2.add(6);

List<Integer> list3 = new ArrayList<>();
list3.add(3);
list3.add(4);
list3.add(5);

boolean disjoint1 = Collections.disjoint(list1, list2);
// 返回 true（没有交集）
System.out.println(disjoint1); // true

boolean disjoint2 = Collections.disjoint(list1, list3);
// 返回 false（有交集：3）
System.out.println(disjoint2); // false

⑱ emptyList() / emptySet() / emptyMap()

用法： 返回一个空的不可变集合。常用于避免返回 null。

// 返回空的不可变List
List<String> emptyList = Collections.emptyList();
// emptyList.add("a"); // ❌ 抛出 UnsupportedOperationException
System.out.println(emptyList); // []

// 返回空的不可变Set
Set<Integer> emptySet = Collections.emptySet();

// 返回空的不可变Map
Map<String, String> emptyMap = Collections.emptyMap();

⑲ singletonList(T o) / singleton(T o) / singletonMap(K key, V value)

用法： 返回只包含一个元素的不可变集合。

// 单元素List
List<String> singleList = Collections.singletonList("hello");
// singleList.add("world"); // ❌ 抛出 UnsupportedOperationException
System.out.println(singleList); // [hello]

// 单元素Set
Set<Integer> singleSet = Collections.singleton(100);

// 单元素Map
Map<String, Integer> singleMap = Collections.singletonMap("key", 123);
System.out.println(singleMap); // {key=123}

⑳ unmodifiableList(List<? extends T> list) / unmodifiableSet() / unmodifiableMap()

用法： 返回指定集合的不可修改视图。任何修改操作都会抛出异常。

List<Integer> original = new ArrayList<>();
original.add(1);
original.add(2);
original.add(3);

List<Integer> unmodifiable = Collections.unmodifiableList(original);
System.out.println(unmodifiable); // [1, 2, 3]

// unmodifiable.add(4); // ❌ 抛出 UnsupportedOperationException

// 但原集合改变会影响不可修改视图
original.add(4);
System.out.println(unmodifiable); // [1, 2, 3, 4]（视图也变了）

㉑ synchronizedList(List list) / synchronizedSet() / synchronizedMap()

用法： 返回线程安全的集合。所有方法都被同步保护。

// 普通List不是线程安全的
List<String> list = new ArrayList<>();

// 转为线程安全的List
List<String> syncList = Collections.synchronizedList(list);

// 同样适用于Set和Map
Set<String> syncSet = Collections.synchronizedSet(new HashSet<>());
Map<String, String> syncMap = Collections.synchronizedMap(new HashMap<>());

// 注意：迭代时需要手动同步
synchronized (syncList) {
for (String s : syncList) {
System.out.println(s);
}
}

㉒ nCopies(int n, T o)

用法： 返回由 n 个相同元素组成的不可变列表。

List<Integer> list = Collections.nCopies(5, 10);
// 列表状态: [10, 10, 10, 10, 10]
System.out.println(list); // [10, 10, 10, 10, 10]
// list.add(20); // ❌ 抛出 UnsupportedOperationException

㉓ enumeration(Collection c)

用法： 返回集合的旧版迭代器 Enumeration。

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");

Enumeration<String> enumeration = Collections.enumeration(list);
while (enumeration.hasMoreElements()) {
System.out.println(enumeration.nextElement());
}
// 输出:
// a
// b
// c

㉔ list(Enumeration e)

用法： 将 Enumeration 转换为 ArrayList。

Vector<String> vector = new Vector<>();
vector.add("x");
vector.add("y");
vector.add("z");

Enumeration<String> enumObj = vector.elements();
List<String> list = Collections.list(enumObj);
// 列表状态: [x, y, z]
System.out.println(list); // [x, y, z]

㉕ checkedList(List list, Class type) / checkedSet() / checkedMap()

用法： 返回类型安全的集合，在运行时检查添加的元素类型。

// 普通List可以混入不同类型
List rawList = new ArrayList();
rawList.add("hello");
rawList.add(123); // 可以混入

// 类型安全的List
List<String> safeList = Collections.checkedList(
new ArrayList<>(),
String.class
);
safeList.add("hello");
// safeList.add(123); // ❌ 抛出 ClassCastException

快速参考表