在Java中如何实现多条件排序

在Java开发中，集合数据的多条件排序是常见需求，比如对用户信息先按年龄升序排序，年龄相同再按注册时间降序排序，或者先按部门编号排序，部门相同再按工资降序排序。Java提供了多种实现多条件排序的方式，开发者可以根据项目使用的Java版本和具体场景选择合适的方法。

使用Comparator接口实现多条件排序

Comparator是Java中用于定义自定义排序规则的核心接口，通过实现它的compare方法可以指定多个排序条件。传统的写法是通过匿名内部类或者实现Comparator接口的类来定义排序规则，多个条件之间通过逻辑判断串联。

基础实体类定义

首先定义一个用于演示的User实体类，包含姓名、年龄、工资三个字段，后续的所有排序示例都基于这个实体类。

public class User {
    private String name;
    private int age;
    private double salary;

    public User(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    // getter和setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + ", salary=" + salary + "}";
    }
}

传统匿名内部类方式

通过匿名内部类实现Comparator接口，在compare方法中先判断第一个条件，如果第一个条件不相等就返回比较结果，否则继续判断第二个条件，以此类推。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class MultiSortDemo {
    public static void main(String[] args) {
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三", 25, 8000));
        userList.add(new User("李四", 25, 9000));
        userList.add(new User("王五", 30, 7000));
        userList.add(new User("赵六", 20, 8500));

        // 先按年龄升序，年龄相同再按工资降序
        Comparator<User> comparator = new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                // 先比较年龄
                int ageCompare = Integer.compare(o1.getAge(), o2.getAge());
                if (ageCompare != 0) {
                    return ageCompare;
                }
                // 年龄相同再比较工资，降序用o2减o1
                return Double.compare(o2.getSalary(), o1.getSalary());
            }
        };

        Collections.sort(userList, comparator);
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

Java 8之后的Comparator链式调用

Java 8对Comparator接口做了增强，新增了comparing、thenComparing等方法，可以通过链式调用的方式非常简洁地实现多条件排序，不需要手动写嵌套的条件判断逻辑。

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class MultiSortDemo2 {
    public static void main(String[] args) {
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三", 25, 8000));
        userList.add(new User("李四", 25, 9000));
        userList.add(new User("王五", 30, 7000));
        userList.add(new User("赵六", 20, 8500));

        // 先按年龄升序，年龄相同再按工资降序
        userList.sort(
            Comparator.comparing(User::getAge)  // 第一个排序条件：年龄升序
                .thenComparing(Comparator.comparing(User::getSalary).reversed())  // 第二个条件：工资降序
        );

        userList.forEach(System.out::println);
    }
}

使用Stream API实现多条件排序

Java 8引入的Stream API也支持排序操作，通过sorted方法传入Comparator规则即可实现多条件排序，适合在流式处理的场景中直接使用。

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class MultiSortDemo3 {
    public static void main(String[] args) {
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三", 25, 8000));
        userList.add(new User("李四", 25, 9000));
        userList.add(new User("王五", 30, 7000));
        userList.add(new User("赵六", 20, 8500));

        // 先按年龄升序，年龄相同再按姓名降序
        List<User> sortedList = userList.stream()
            .sorted(
                Comparator.comparing(User::getAge)
                    .thenComparing(User::getName, Comparator.reverseOrder())
            )
            .collect(Collectors.toList());

        sortedList.forEach(System.out::println);
    }
}

多条件排序的注意事项

• 排序条件的顺序很重要，前面的条件优先级更高，只有当前面的条件判断为相等时，才会执行后面的条件判断。
• 使用基本类型的包装类比较时，优先使用对应包装类的compare方法，比如Integer.compare、Double.compare，避免手动做减法可能出现的溢出问题。
• 如果排序的字段可能为null，需要使用Comparator.nullsFirst或者Comparator.nullsLast来处理空值，避免空指针异常。比如处理可能为null的年龄字段：Comparator.comparing(User::getAge, Comparator.nullsFirst(Integer::compare))。
• 对于不需要修改原集合的场景，使用Stream的sorted方法更合适，因为它会返回一个新的排序后的集合，不会修改原集合；如果需要直接修改原集合，使用集合的sort方法更高效。

常见场景示例

假设有一个订单实体类，需要按照订单状态升序、创建时间降序、订单金额降序三个条件排序，实现代码如下：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

class Order {
    private int status; // 订单状态 1待支付 2已支付 3已完成
    private long createTime; // 创建时间戳
    private double amount; // 订单金额

    public Order(int status, long createTime, double amount) {
        this.status = status;
        this.createTime = createTime;
        this.amount = amount;
    }

    public int getStatus() {
        return status;
    }

    public long getCreateTime() {
        return createTime;
    }

    public double getAmount() {
        return amount;
    }

    @Override
    public String toString() {
        return "Order{status=" + status + ", createTime=" + createTime + ", amount=" + amount + "}";
    }
}

public class OrderSortDemo {
    public static void main(String[] args) {
        List<Order> orderList = new ArrayList<>();
        orderList.add(new Order(2, 1690000000L, 500));
        orderList.add(new Order(1, 1690000100L, 300));
        orderList.add(new Order(2, 1690000000L, 800));
        orderList.add(new Order(3, 1689999900L, 1000));

        // 先按状态升序，状态相同按创建时间降序，创建时间相同按金额降序
        orderList.sort(
            Comparator.comparing(Order::getStatus)
                .thenComparing(Order::getCreateTime, Comparator.reverseOrder())
                .thenComparing(Order::getAmount, Comparator.reverseOrder())
        );

        orderList.forEach(System.out::println);
    }
}

Java多条件排序ComparatorCollectionsStream修改时间：2026-07-01 21:06:20