在Java中，Arrays.sort 用于对数组元素进行排序。当数组元素是引用类型时，排序行为与基本类型数组存在明显差异。基本类型数组主要依赖数值大小比较，而引用类型数组默认会调用对象自身的 compareTo 方法，按照自然顺序进行排序。如果对象所属的类没有实现 Comparable 接口，或者虽然实现了该接口但当前业务需要完全不同的排序规则，就必须向 Arrays.sort 传入一个自定义比较器。自定义比较器的核心是 Comparator 接口，它可以独立于对象自身的比较逻辑，灵活定义各种排序方式。
基于 Comparator 接口实现自定义比较器
Comparator 是 Java 提供的一个函数式接口，其中最重要的方法是 compare。该方法接收两个参数，通常命名为 o1 和 o2，返回一个 int 值。当返回负整数时，表示 o1 应该排在 o2 前面；返回零表示两者在排序中视为相等；返回正整数则表示 o2 应该排在 o1 前面。通过实现这一约定，Arrays.sort 就可以按照我们给定的规则排列数组元素。
下面先定义一个引用类型 User，它包含 id 和年龄两个属性。这个类没有实现 Comparable 接口，因此如果直接对它进行排序，编译器或运行时无法确定自然顺序，必须显式提供比较器。
// 用户类，包含id和年龄两个属性
class User {
private int id;
private int age;
public User(int id, int age) {
this.id = id;
this.age = age;
}
public int getId() {
return id;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "User{id=" + id + ", age=" + age + "}";
}
}
针对年龄升序排序的需求，可以使用匿名内部类实现 Comparator 接口。在 compare 方法中返回 o1.getAge() - o2.getAge()，即可让年龄较小的用户排在前面。
import java.util.Arrays;
import java.util.Comparator;
public class ArraySortDemo {
public static void main(String[] args) {
// 创建引用类型数组
User[] users = new User[]{
new User(1, 25),
new User(2, 18),
new User(3, 30)
};
// 定义自定义比较器，按照年龄升序排序
Comparator<User> ageComparator = new Comparator<User>() {
@Override
public int compare(User o1, User o2) {
// 年龄小的排在前面
return o1.getAge() - o2.getAge();
}
};
// 使用Arrays.sort传入数组和自定义比较器
Arrays.sort(users, ageComparator);
// 输出排序后的结果
for (User user : users) {
System.out.println(user);
}
}
}
执行上述代码后，数组会按照年龄从 18 到 30 的顺序排列。可以看到，自定义比较器并不要求 User 类本身实现任何排序接口，排序规则完全由比较器决定，这也让排序逻辑与对象模型解耦。
使用 lambda 表达式简化比较器定义
由于 Comparator 是函数式接口，只包含一个抽象方法，因此可以用 lambda 表达式替代匿名内部类。lambda 表达式的参数类型通常可以省略，因为编译器会根据 Arrays.sort 的签名推断出它们都是 User 类型。这种方式去掉了接口名、方法名和 @Override 等冗余结构，使代码更加直观。
仍然使用年龄升序的例子，lambda 表达式可以写成 (o1, o2) -> o1.getAge() - o2.getAge()。当表达式主体只有一行时，不需要写 return 关键字，计算结果会自动作为返回值。
import java.util.Arrays;
public class ArraySortLambdaDemo {
public static void main(String[] args) {
User[] users = new User[]{
new User(1, 25),
new User(2, 18),
new User(3, 30)
};
// 使用lambda表达式定义比较器，按照年龄升序排序
Arrays.sort(users, (o1, o2) -> o1.getAge() - o2.getAge());
for (User user : users) {
System.out.println(user);
}
}
}
如果需要降序排列，只需交换比较顺序。比较器的返回值决定了元素的前后位置，因此将 o1.getAge() - o2.getAge() 改成 o2.getAge() - o1.getAge()，就能让年龄大的用户排在前面。
import java.util.Arrays;
public class ArraySortLambdaDescDemo {
public static void main(String[] args) {
User[] users = new User[]{
new User(1, 25),
new User(2, 18),
new User(3, 30)
};
// 使用lambda表达式定义比较器，按照年龄降序排序
Arrays.sort(users, (o1, o2) -> o2.getAge() - o1.getAge());
for (User user : users) {
System.out.println(user);
}
}
}
使用 lambda 表达式时仍需注意 compare 方法的返回约定。无论表达式写得多么简短，其本质仍然是返回一个整数来表示两个对象的先后顺序。代码越简洁，越需要确认比较方向是否正确。
多条件排序与空值处理
实际业务场景中，仅按一个字段排序往往不够。例如用户列表可能需要先按年龄升序排列，当年龄相同时再按 id 升序排列。这种需求可以在 compare 方法中依次判断多个条件：先比较第一个字段，如果结果不为零就直接返回；如果结果为零，再比较第二个字段。这样就能形成稳定的多级排序规则。
import java.util.Arrays;
public class MultiConditionSortDemo {
public static void main(String[] args) {
User[] users = new User[]{
new User(1, 25),
new User(2, 18),
new User(3, 25),
new User(4, 30)
};
// 多条件排序：先按年龄升序，年龄相同按id升序
Arrays.sort(users, (o1, o2) -> {
// 先比较年龄
int ageCompare = o1.getAge() - o2.getAge();
if (ageCompare != 0) {
return ageCompare;
}
// 年龄相同再比较id
return o1.getId() - o2.getId();
});
for (User user : users) {
System.out.println(user);
}
}
}
上面的例子中，两个年龄为 25 的用户会继续根据 id 比较，结果是 id 较小的 1 排在 id 为 3 的前面。通过层层返回比较结果，可以扩展任意数量的排序条件，逻辑清晰且易于维护。
当数组可能包含 null 元素时，比较器还必须处理空值，否则调用 null.getAge() 会触发 NullPointerException。常见的策略是让 null 元素统一排在数组前面或后面，这样既不会中断排序过程，也能保证非空元素之间仍然按照业务规则排序。
import java.util.Arrays;
public class NullHandleSortDemo {
public static void main(String[] args) {
User[] users = new User[]{
new User(1, 25),
null,
new User(2, 18),
null
};
// 处理空值的比较器，null元素排在前面
Arrays.sort(users, (o1, o2) -> {
if (o1 == null && o2 == null) {
return 0;
}
if (o1 == null) {
return -1; // o1是null，排在前面
}
if (o2 == null) {
return 1; // o2是null，排在后面
}
return o1.getAge() - o2.getAge();
});
for (User user : users) {
System.out.println(user);
}
}
}
代码中先判断双方都为空返回 0，再处理单方为空的情况。返回 -1 表示 o1 放在前面，因此当 o1 为 null 时它会被排到数组前端；返回 1 则表示 o2 放到后面。实际开发中也可以反转这两个值，让空值统一排在末尾
不过，手写判空逻辑虽然能实现预期的排序效果，但返回值的符号与元素位置之间的关系容易混淆，而且判空模板代码比较冗长。Java 8 在 Comparator 接口中提供了两个静态工厂方法 nullsFirst 和 nullsLast，专门用于处理空元素。它们接收一个底层比较器，并分别将 null 元素排到非空元素的前面或末尾。
// 按年龄升序，null 排在前面 Arrays.sort(users, Comparator.nullsFirst(Comparator.comparingInt(User::getAge))); // 按年龄升序，null 排在末尾 Arrays.sort(users, Comparator.nullsLast(Comparator.comparingInt(User::getAge)));
如果需要按年龄降序排列，同时保持 null 在前，要注意 reversed() 的调用位置。nullsFirst 返回的仍然是一个比较器，如果在其外层直接调用 reversed()，会连同空值的先后关系一起反转，导致 null 被排到末尾。
// 错误：整体反转后，null 会排到末尾 Arrays.sort(users, Comparator.nullsFirst(Comparator.comparingInt(User::getAge)).reversed()); // 正确：先反转非空元素比较器，再包装空值策略 Arrays.sort(users, Comparator.nullsFirst(Comparator.comparingInt(User::getAge).reversed()));
对于 List 或流式操作同样适用。使用 List.sort 时直接传入包装后的比较器即可，流式排序也可以安全处理 null。
List<User> list = Arrays.asList(
new User(1, 25),
null,
new User(2, 18)
);
list.sort(Comparator.nullsLast(Comparator.comparingInt(User::getAge)));
如果在业务上允许丢弃空元素，也可以先过滤再排序，代码会更简洁。
List<User> sortedUsers = userList.stream()
.filter(Objects::nonNull)
.sorted(Comparator.comparingInt(User::getAge))
.collect(Collectors.toList());
Java 对象数组的 Arrays.sort 以及 List.sort 底层采用 TimSort，排序是稳定的。对于相等的非空元素，它们会保持原始相对顺序。多个 null 之间虽然顺序稳定，但业务上通常不关心 null 之间的先后。使用 nullsFirst 或 nullsLast 不会破坏这一稳定性。
总之，处理包含空值的对象数组或集合排序时，推荐使用 Comparator.nullsFirst 或 Comparator.nullsLast 包装实际的属性比较器。这样既能避免 NullPointerException，又能清晰表达空值的处理策略。同时要留意 reversed() 的调用层级，以及是否需要在排序前过滤 null。合理运用这些 API，可以让排序逻辑更健壮、更易读。
至此，关于 Java 排序中空值处理的讨论就全部结束。
JavaArrays.sort自定义比较器引用类型数组修改时间：2026-07-23 15:51:36