1. 数组排序基础与常见场景解析
在算法和数据结构的学习中，数组排序是最基础也最常遇到的问题之一。无论是准备技术面试还是日常开发，掌握各种场景下的数组排序技巧都能显著提升编码效率。Java中的Arrays.sort()方法虽然强大，但在不同场景下的使用方式却有很大差异，特别是涉及到降序排列和二维数组排序时，很多初学者容易踩坑。
1.1 一维数组的基本排序
对于一维数组的升序排序，Java提供了非常简洁的API：
java复制int[] arr = {5, 2, 9, 1, 5};
Arrays.sort(arr); // 升序排序
System.out.println(Arrays.toString(arr)); // 输出 [1, 2, 5, 5, 9]
这里需要注意的是，Arrays.sort()对于基本类型数组（如int[], double[]等）使用的是优化后的快速排序算法，时间复杂度为O(n log n)。而对于对象数组（如Integer[], String[]等），则使用的是TimSort算法，这是一种结合了归并排序和插入排序的稳定排序算法。
注意：基本类型数组和对象数组的排序实现有本质区别。基本类型排序是原地修改且不稳定的，而对象数组排序是稳定的（相等元素的相对位置保持不变）。
1.2 一维数组的降序排序陷阱
很多初学者会尝试这样实现降序排序：
java复制// 错误示范！这不适用于基本类型数组
Arrays.sort(arr, (a, b) -> b - a);
实际上，对于基本类型数组（如int[]），Java不允许传入Comparator，因为基本类型不是对象。正确的降序排序方式应该是先升序排序，然后反转数组：
java复制public static void reverseArray(int[] arr) {
for (int i = 0; i < arr.length / 2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
}
Arrays.sort(arr); // 先升序
reverseArray(arr); // 再反转得到降序
对于对象数组（如Integer[]），则可以直接使用Comparator：
java复制Integer[] arr = {5, 2, 9, 1, 5};
Arrays.sort(arr, Collections.reverseOrder()); // 降序排序
2. 二维数组的灵活排序技巧
2.1 按指定列排序
二维数组的排序在实际应用中更为常见，比如处理表格数据、坐标点排序等场景。Java中可以使用Lambda表达式轻松实现：
java复制// 按每行的第2个元素升序排序
int[][] arr = {{1, 9}, {2, 5}, {3, 7}};
Arrays.sort(arr, (o1, o2) -> o1[1] - o2[1]);
// 结果：[[2,5], [3,7], [1,9]]
降序排序只需调换比较顺序：
java复制Arrays.sort(arr, (o1, o2) -> o2[1] - o1[1]);
// 结果：[[1,9], [3,7], [2,5]]
2.2 多条件排序
实际业务中经常需要多级排序，比如先按第一列排序，如果相同再按第二列排序：
java复制int[][] points = {{1,3}, {1,2}, {2,1}, {1,1}};
Arrays.sort(points, (a, b) -> {
if (a[0] != b[0]) {
return Integer.compare(a[0], b[0]); // 第一列升序
} else {
return Integer.compare(a[1], b[1]); // 第二列升序
}
});
// 结果：[[1,1], [1,2], [1,3], [2,1]]
2.3 浮点数排序的精度问题
处理浮点型二维数组时，直接相减并强制转换会导致精度丢失：
java复制// 错误示范！可能导致精度丢失
double[][] arr = {{1.1, 2.3}, {1.1, 2.1}};
Arrays.sort(arr, (o1, o2) -> (int)(o2[1] - o1[1])); // 错误！
正确做法是使用Double.compare()：
java复制double[][] arr = {{1.1, 2.3}, {1.1, 2.1}, {1.2, 2.0}};
Arrays.sort(arr, (o1, o2) -> Double.compare(o2[1], o1[1])); // 按第二列降序
// 结果：[[1.1,2.3], [1.1,2.1], [1.2,2.0]]
3. 高级排序场景与性能优化
3.1 自定义对象数组排序
对于自定义对象数组，可以实现Comparable接口或提供Comparator：
java复制class Point implements Comparable<Point> {
int x, y;
Point(int x, int y) { this.x = x; this.y = y; }
@Override
public int compareTo(Point other) {
return this.x != other.x ? Integer.compare(this.x, other.x)
: Integer.compare(this.y, other.y);
}
}
Point[] points = new Point[3];
// 填充数据后可以直接排序
Arrays.sort(points);
或者使用更灵活的Comparator：
java复制Arrays.sort(points, Comparator
.comparingInt((Point p) -> p.x)
.thenComparingInt(p -> p.y));
3.2 大数组排序的性能考量
当处理大型数组时，排序性能变得尤为重要：
- 对于基本类型数组，Arrays.sort()使用双轴快速排序，平均时间复杂度O(n log n)
- 对于近乎有序的数据，可考虑使用插入排序优化的小数组阈值
- 并行排序：Java8提供了parallelSort()方法
java复制int[] largeArray = new int[1_000_000];
// 使用并行排序
Arrays.parallelSort(largeArray);
3.3 稳定排序与非稳定排序
在某些场景下，保持相等元素的原始顺序很重要：
- 对象数组的Arrays.sort()是稳定的
- 基本类型数组的排序是不稳定的
- 如果需要稳定排序基本类型，可以先将它们装箱为对象数组
4. 常见问题与实战技巧
4.1 边界条件处理
在实际编码中，我们需要考虑各种边界情况：
java复制// 空数组或null检查
if (arr == null || arr.length == 0) {
return;
}
// 单元素数组无需排序
if (arr.length == 1) {
return arr;
}
4.2 比较器实现的注意事项
编写Comparator时要注意以下几点：
- 避免整数溢出：使用Integer.compare(a, b)而不是a - b
- 处理null值：Objects.compare(a, b, comparator)
- 确保比较关系满足传递性
java复制// 更安全的比较方式
Arrays.sort(arr, (a, b) -> Integer.compare(a[0], b[0]));
// 处理可能为null的情况
Arrays.sort(arr, Comparator.nullsFirst(Comparator.naturalOrder()));
4.3 排序算法选择建议
虽然Arrays.sort()已经做了很好的默认选择，但在特殊场景下可以考虑：
- 小数组（<47个元素）：插入排序更高效
- 几乎有序的数组：TimSort表现极佳
- 大量重复元素：三向快速排序可能更好
- 原始类型vs对象：考虑内存和缓存效率
4.4 实际开发中的经验分享
- 测试驱动：总是为排序逻辑编写单元测试，特别是边界情况
- 性能分析：对于大型数据集，使用JMH进行基准测试
- 代码可读性：复杂的比较逻辑应该提取为独立方法或Comparator实现
- API文档：自定义排序逻辑应该添加清晰的注释说明排序规则
java复制/**
* 按照先x升序，后y降序的方式比较两个点
*/
static final Comparator<Point> XY_ORDER = (p1, p2) -> {
if (p1.x != p2.x) return Integer.compare(p1.x, p2.x);
return Integer.compare(p2.y, p1.y); // 注意这里是降序
};
我在实际项目中发现，清晰的排序规则定义可以避免很多后续维护问题。特别是在团队协作中，明确定义的Comparator比内联Lambda表达式更易于理解和维护。