归并排序是稳定的分治类排序算法，时间复杂度稳定为O(n log n)，适合处理大规模数据排序场景。通过泛型化改造和Comparator接口结合，可以让归并排序适配任意数据类型，同时支持多字段的动态排序规则配置。本文就来实现这个通用的排序工具。
实现思路说明
整个实现分为三个核心部分：首先是泛型类的定义，通过泛型边界约束入参类型；其次是归并排序的分治逻辑实现，包括数组拆分和有序数组合并；最后是多字段排序规则的适配，通过Comparator链实现动态排序优先级配置。
泛型类定义
我们定义一个泛型类MergeSort，泛型参数T需要是Comparable的子类型吗？其实不需要，因为我们后续会通过Comparator来比较元素，这样可以更灵活地支持自定义比较规则。类的核心方法是sort，接收待排序数组和Comparator参数。
归并排序核心逻辑
归并排序的核心逻辑分为两步：
- 拆分：将数组递归拆分成左右两个子数组，直到子数组长度为1
- 合并：将两个有序的子数组合并成一个新的有序数组
完整代码实现
泛型归并排序工具类
以下是完整的泛型化归并排序实现代码，支持传入Comparator实现自定义排序规则：
import java.util.Comparator;
public class MergeSort<T> {
// 对外暴露的排序方法，接收待排序数组和比较器
public void sort(T[] arr, Comparator<? super T> comparator) {
if (arr == null || arr.length <= 1) {
return;
}
// 临时数组用于合并过程
T[] temp = (T[]) new Object[arr.length];
mergeSort(arr, temp, 0, arr.length - 1, comparator);
}
// 递归拆分数组
private void mergeSort(T[] arr, T[] temp, int left, int right, Comparator<? super T> comparator) {
if (left >= right) {
return;
}
int mid = left + (right - left) / 2;
// 递归排序左半部分
mergeSort(arr, temp, left, mid, comparator);
// 递归排序右半部分
mergeSort(arr, temp, mid + 1, right, comparator);
// 合并两个有序子数组
merge(arr, temp, left, mid, right, comparator);
}
// 合并两个有序子数组
private void merge(T[] arr, T[] temp, int left, int mid, int right, Comparator<? super T> comparator) {
// 将待合并的区间复制到临时数组
for (int i = left; i <= right; i++) {
temp[i] = arr[i];
}
int i = left;
int j = mid + 1;
int k = left;
// 比较两个子数组的元素，按规则放入原数组
while (i <= mid && j <= right) {
if (comparator.compare(temp[i], temp[j]) <= 0) {
arr[k] = temp[i];
i++;
} else {
arr[k] = temp[j];
j++;
}
k++;
}
// 处理剩余元素
while (i <= mid) {
arr[k] = temp[i];
i++;
k++;
}
while (j <= right) {
arr[k] = temp[j];
j++;
k++;
}
}
}
多字段动态排序实现
要实现多字段动态排序，只需要自定义Comparator，通过链式比较实现多字段优先级。比如我们有一个用户类，需要先按年龄升序，年龄相同再按姓名降序：
// 用户实体类
class User {
private String name;
private int age;
private String department;
public User(String name, int age, String department) {
this.name = name;
this.age = age;
this.department = department;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public String getDepartment() {
return department;
}
@Override
public String toString() {
return "User{name='" + name + "', age=" + age + ", department='" + department + "'}";
}
}
// 测试多字段排序
public class TestMergeSort {
public static void main(String[] args) {
User[] users = new User[]{
new User("张三", 25, "研发部"),
new User("李四", 22, "产品部"),
new User("王五", 25, "测试部"),
new User("赵六", 22, "研发部")
};
MergeSort<User> mergeSort = new MergeSort<>();
// 定义多字段排序规则：先按年龄升序，年龄相同按姓名降序
mergeSort.sort(users, (u1, u2) -> {
int ageCompare = Integer.compare(u1.getAge(), u2.getAge());
if (ageCompare != 0) {
return ageCompare;
}
// 姓名降序，所以反过来比较
return u2.getName().compareTo(u1.getName());
});
// 打印排序结果
for (User user : users) {
System.out.println(user);
}
}
}
代码说明
上面的实现中，MergeSort类的泛型参数T没有做边界约束，因为比较逻辑完全交给传入的Comparator处理，这样可以适配任意类型的对象排序。如果不需要自定义排序规则，也可以传入Comparator.naturalOrder()使用对象的自然排序（前提是对象实现了Comparable接口）。
合并操作中使用临时数组避免了频繁创建数组带来的性能开销，递归拆分时取中间位置使用left + (right - left) / 2而不是(left + right) / 2，是为了避免left和right相加溢出的情况。
使用场景说明
这个泛型化归并排序适合以下场景：
- 需要对自定义对象做稳定排序，且不希望修改对象本身的
Comparable实现 - 排序规则是动态的，可能根据业务需求随时调整多字段的排序优先级
- 需要处理大规模数据，希望排序时间复杂度稳定，避免快速排序的最坏情况
如果要支持更多字段的排序，只需要在Comparator的比较逻辑中依次增加字段的比较即可，不需要修改归并排序的核心算法，扩展性很好。
Java归并排序泛型多字段排序Comparator修改时间：2026-06-25 03:36:37