Collections工具类位于java.util包下，它几乎是为List量身打造的一整套静态方法库。不少人对它的印象只停留在sort上，实际上它能完成排序、查找、打乱、填充、同步化包装、不可变包装等十几类操作。这篇文章以排序为主线，把Collections的常用方法过一遍，并给出可直接运行的代码。
一、Collections.sort的两种排序方式
Collections.sort方法有两个重载版本。第一个版本只接收一个List参数，要求集合中的元素实现Comparable接口，也就是所谓的自然排序；第二个版本额外接收一个Comparator，由外部传入比较规则，适合无法修改元素源码或者需要多种排序规则的场合。
先看自然排序的写法。假设有一个存Integer的List，Integer本身已经实现了Comparable，可以直接排：
import java.util.*;
public class SortDemo {
public static void main(String[] args) {
List<Integer> list = new ArrayList<gt;(Arrays.asList(5, 2, 9, 1, 7));
Collections.sort(list);
System.out.println(list); // 输出 [1, 2, 5, 7, 9]
}
}如果元素是自定义类型，就需要让它实现Comparable接口。比如一个Student类按分数排序：
import java.util.*;
class Student implements Comparable<Student> {
String name;
int score;
Student(String name, int score) {
this.name = name;
this.score = score;
}
@Override
public int compareTo(Student o) {
return Integer.compare(this.score, o.score);
}
@Override
public String toString() {
return name + ":" + score;
}
}
public class ComparableDemo {
public static void main(String[] args) {
List<Student> list = new ArrayList<>();
list.add(new Student("张三", 88));
list.add(new Student("李四", 95));
list.add(new Student("王五", 76));
Collections.sort(list);
System.out.println(list); // [王五:76, 张三:88, 李四:95]
}
}自然排序的问题在于规则被固定写死在类里。一旦业务上既要按分数排、又要按姓名排，Comparable就不够用了，这时应该用Comparator。Comparator是独立于元素的策略对象，可以随时替换比较逻辑，符合策略模式的思想，灵活度远高于Comparable。这也是为什么JDK自身的大量API（比如TreeMap、stream的sorted）都更倾向接收Comparator参数。
二、用Comparator实现降序与多字段排序
降序排序是最常见的需求。传统写法是匿名内部类，Java 8之后推荐用Comparator.comparing加reversed，可读性明显更好：
import java.util.*;
public class ComparatorDemo {
public static void main(String[] args) {
List<Integer> nums = new ArrayList<>(Arrays.asList(5, 2, 9, 1));
Collections.sort(nums, Comparator.reverseOrder()); // 降序
System.out.println(nums); // [9, 5, 2, 1]
List<String> names = new ArrayList<>(Arrays.asList("banana", "apple", "cherry"));
Collections.sort(names, Comparator.comparing(String::length)); // 按长度升序
System.out.println(names); // [apple, banana, cherry]
}
}多字段排序用thenComparing串联。典型场景是先按部门排，部门相同再按薪资降序：
import java.util.*;
class Employee {
String dept;
String name;
double salary;
Employee(String dept, String name, double salary) {
this.dept = dept;
this.name = name;
this.salary = salary;
}
@Override
public String toString() {
return dept + "-" + name + "-" + salary;
}
}
public class MultiFieldSort {
public static void main(String[] args) {
List<Employee> list = new ArrayList<>();
list.add(new Employee("研发部", "张三", 15000));
list.add(new Employee("运营部", "李四", 9000));
list.add(new Employee("研发部", "王五", 18000));
Collections.sort(list, Comparator
.comparing((Employee e) -> e.dept)
.thenComparing(Comparator.comparingDouble(Employee::salary).reversed()));
list.forEach(System.out::println);
// 运营部-李四-9000.0
// 研发部-王五-18000.0
// 研发部-张三-15000.0
}
}这里有一个细节需要注意：当链式调用中先写了带Lambda的comparing，后面的thenComparing才能正确推断类型，所以第一处比较显式声明了Employee类型参数。另外要提醒的是Comparator.comparingDouble可以避免自动装箱，在排序大集合时能减少一定的对象创建开销，属于细节层面的优化。
还有一个容易踩的坑：Comparator中返回值只关心正负号，不关心具体数值。新手常写return this.score - o.score这种减法形式，当数值很大或接近整数边界时会发生溢出，导致排序结果错乱。始终使用Integer.compare或Double.compare这类安全方法，是最稳妥的习惯。
三、Collections的其他高频方法
排序之外，Collections还提供了一批实用方法，掌握它们能显著减少代码量：
import java.util.*;
public class CommonOps {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>(Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6));
Collections.reverse(list); // 反转
System.out.println(list); // [6, 2, 9, 5, 1, 4, 1, 3]
Collections.shuffle(list, new Random(42)); // 随机打乱，可指定随机种子
System.out.println(list);
System.out.println(Collections.max(list)); // 最大值
System.out.println(Collections.min(list)); // 最小值
Collections.swap(list, 0, list.size() - 1); // 交换首尾元素
Collections.fill(list, 0); // 全部填充为0
System.out.println(list); // [0, 0, 0, 0, 0, 0, 0, 0]
List<Integer> fixed = Collections.nCopies(5, 8); // 生成5个8的不可变列表
System.out.println(fixed); // [8, 8, 8, 8, 8]
}
}二分查找binarySearch也值得单独说明。它要求数组必须已经升序排列，返回命中的下标，找不到时返回负值。注意这个负值不是随便给的，而是插入点的相反数减一，据此可以算出新元素应该插入的位置：
import java.util.*;
public class BinarySearchDemo {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>(Arrays.asList(1, 3, 5, 7, 9));
int idx = Collections.binarySearch(list, 5);
System.out.println("5的下标：" + idx); // 3？不，是 2
int miss = Collections.binarySearch(list, 4);
System.out.println("未命中返回：" + miss); // -3
System.out.println("应插入位置：" + (-miss - 1)); // 2
}
}在集合安全方面，unmodifiableList返回只读视图，外部调用方对它做add会直接抛出UnsupportedOperationException，常用于方法返回值防止调用方篡改内部数据。synchronizedList则把普通ArrayList包装成线程安全版本，各方法都加了同步锁。不过在并发场景下更推荐java.util.concurrent包下的CopyOnWriteArrayList和ConcurrentLinkedDeque，它们的并发粒度更细，读多写少时性能优势明显。另外要记住，unmodifiableList只是视图而非拷贝，原List发生变化时视图内容会跟着变，如果需要真正隔离，还是要拷贝一份。
四、Collections.sort、List.sort与stream排序怎么选
Java 8给List接口增加了默认方法sort，Collection的静态排序实际上会走到TimSort这一归并排序的改进版本，时间复杂度稳定在O(n log n)，且对已经部分有序的数据有很好的适应性，不会出现快排在极端情况下的退化。两种写法效果等价：
import java.util.*;
public class SortCompare {
public static void main(String[] args) {
List<Integer> a = new ArrayList<>(Arrays.asList(4, 2, 8, 1));
Collections.sort(a); // 写法一：工具类
a.sort(Comparator.naturalOrder()); // 写法二：实例方法
// 写法三：stream不改动原集合，生成新列表
List<Integer> sorted = a.stream()
.sorted(Comparator.reverseOrder())
.toList();
System.out.println(sorted);
}
}三者的选择标准很清晰：需要原地修改、节省内存时用Collections.sort或list.sort；希望保留原顺序、得到一个新的有序集合时用stream的sorted。stream方案每次都会产生中间的流对象和新的结果列表，数据量大时内存占用更高，但它不污染原数据，在函数式风格的代码里更自然。
最后提醒两个排序相关的异常场景。第一，对包含null元素的List排序，默认的Comparator会在比较null时抛出NullPointerException，可以用Comparator.nullsFirst或nullsLast把null值安排在最前或最后。第二，被unmodifiableList包装的集合调用sort会抛异常，因为sort本质上是set操作，只读集合当然不允许。理解了这些边界情况，Collections这套工具在日常开发中基本就能用得得心应手了。
Collections工具类Java集合排序Java集合操作修改时间：2026-09-12 23:58:39