一、核心概念与底层实现
Java 的排序方法遵循最佳实践，底层根据数据类型做了优化：
- 对
int、long等基本类型数组：使用双轴快速排序（Dual-Pivot QuickSort），效率更高（时间复杂度 O(n log n)）。 - 对
String、自定义对象等引用类型：使用TimSort（归并排序 + 插入排序的混合算法），稳定且高效。
二、常用.sort 方法用法
1. Arrays.sort()（数组排序）
适用于所有数组类型（基本类型、引用类型），默认升序排列。
示例 1：基本类型数组排序（int 数组）
import java.util.Arrays;
public class SortDemo {
public static void main(String[] args) {
// 定义无序 int 数组
int[] nums = {5, 2, 9, 1, 5, 6};
// 核心：数组排序（原地排序，直接修改原数组）
Arrays.sort(nums);
// 输出结果：[1, 2, 5, 5, 6, 9]
System.out.println(Arrays.toString(nums));
}
}
示例 2：自定义对象数组排序（实现 Comparable）
如果要排序自定义对象，需让对象类实现 Comparable 接口，重写 compareTo 方法定义'自然排序规则'。
import java.util.Arrays;
// 自定义 User 类，实现 Comparable 接口
class User implements Comparable<User> {
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
// 定义排序规则：按年龄升序（this.age - o.age），降序则反过来
@Override
public int compareTo(User o) {
return this.age - o.age;
}
// 重写 toString，方便打印
@Override
public String toString() {
return "User{name='" + name + "', age=" + age + "}";
}
}
public class ObjectSortDemo {
public static void main(String[] args) {
User[] users = {new User("张三", 25), new User("李四", 20), new User("王五", 30)};
// 排序自定义对象数组
Arrays.sort(users);
// 输出结果：按年龄升序排列
// [User{name='李四', age=20}, User{name='张三', age=25}, User{name='王五', age=30}]
System.out.println(Arrays.toString(users));
}
}
示例 3：自定义排序规则（Comparator）
如果不想修改对象类（比如第三方类），或需要临时自定义排序规则，可使用带 Comparator 的重载方法：
import java.util.Arrays;
import java.util.Comparator;
public class ComparatorSortDemo {
public static void main(String[] args) {
String[] strs = {"apple", "Banana", "cherry", "date"};
// 按字符串长度降序排序（忽略大小写）
Arrays.sort(strs, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
// 降序：s2 长度 - s1 长度
int lenCompare = s2.length() - s1.length();
// 长度相同则按字母序（忽略大小写）
return lenCompare != 0 ? lenCompare : s1.compareToIgnoreCase(s2);
}
});
// 输出：[cherry, Banana, apple, date]
System.out.println(Arrays.toString(strs));
}
}
2. Collections.sort()（List 集合排序）
专门用于 List 接口的实现类（如 ArrayList、LinkedList），用法和 Arrays.sort() 类似，默认升序。
示例：List 集合排序（Lambda 简化 Comparator）
Java 8+ 支持 Lambda 表达式，可简化 Comparator 的写法：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ListSortDemo {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(8);
list.add(2);
list.add(7);
list.add(1);
// 方式 1：默认升序
Collections.sort(list);
System.out.println("升序：" + list);
// [1, 2, 7, 8]
// 方式 2：Lambda 自定义降序
Collections.sort(list, (a, b) -> b - a);
System.out.println("降序：" + list);
// [8, 7, 2, 1]
}
}
三、关键注意事项
Arrays.sort()是原地排序：直接修改原数组，不会返回新数组；- 基本类型数组的排序是不稳定的，引用类型排序是稳定的；
Java 8+ 还提供了 List.sort() 方法（替代 Collections.sort()），写法更简洁：
list.sort((a, b) -> b - a); // 等价于 Collections.sort(list, ...)
总结
- Java 的.sort 核心分为
Arrays.sort()（数组）和Collections.sort()（List），底层优化保证高性能； - 排序规则分两种：实现
Comparable定义'自然排序'，或传入Comparator实现'定制排序'； - Java 8+ 推荐用 Lambda 简化 Comparator，
List.sort()替代Collections.sort()更简洁。
