集合指定属性排序优化：适配POJO属性变更与泛型多属性需求

针对你的需求，这里提供一个完全泛型化、支持多属性排序且无需随POJO属性变更修改的工具类方案，解决原代码硬编码、单属性限制、非泛型的问题。

核心优化点 #

• 泛型支持：适配任意POJO类，无需针对特定类编写排序逻辑
• 动态属性映射：通过反射自动关联POJO属性的getter方法，属性增删改无需修改排序代码
• 多属性链式排序：支持"name: desc, emailId asc"格式的排序表达式，按优先级依次排序
• null值处理：默认将null值排在末尾，避免空指针异常

完整实现代码 #

import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class GenericSortUtils {

    // 泛型排序方法，支持任意POJO类
    public static <T> List<T> sort(List<T> list, String sortExpression) {
        if (list == null || list.isEmpty() || sortExpression == null || sortExpression.isBlank()) {
            return list;
        }

        // 解析排序表达式为排序项列表
        List<SortItem> sortItems = parseSortExpression(sortExpression);

        // 链式构建Comparator
        Comparator<T> comparator = sortItems.stream()
                .map(GenericSortUtils::buildPropertyComparator)
                .reduce(Comparator::thenComparing)
                .orElse(Comparator.naturalOrder());

        // 执行排序
        list.sort(comparator);
        return list;
    }

    // 解析排序表达式，拆分属性名和排序方向
    private static List<SortItem> parseSortExpression(String sortExpression) {
        return List.of(sortExpression.split(","))
                .stream()
                .map(String::trim)
                .filter(item -> !item.isBlank())
                .map(item -> {
                    String[] parts = item.split(":");
                    String property = parts[0].trim();
                    SortDirection direction = parts.length > 1 
                            ? SortDirection.fromString(parts[1].trim()) 
                            : SortDirection.ASC;
                    return new SortItem(property, direction);
                })
                .collect(Collectors.toList());
    }

    // 为单个属性构建Comparator，处理反射、null值和排序方向
    private static <T> Comparator<T> buildPropertyComparator(SortItem sortItem) {
        return (o1, o2) -> {
            try {
                // 通过属性名获取对应的getter方法
                PropertyDescriptor pd = new PropertyDescriptor(sortItem.getProperty(), o1.getClass());
                Method getter = pd.getReadMethod();
                Object value1 = getter.invoke(o1);
                Object value2 = getter.invoke(o2);

                // 处理null值：默认null排在末尾，可根据需求调整
                if (value1 == null && value2 == null) return 0;
                if (value1 == null) return sortItem.getDirection() == SortDirection.ASC ? 1 : -1;
                if (value2 == null) return sortItem.getDirection() == SortDirection.ASC ? -1 : 1;

                // 执行属性值比较（要求属性实现Comparable接口）
                @SuppressWarnings("unchecked")
                Comparable<Object> comparableValue = (Comparable<Object>) value1;
                int compareResult = comparableValue.compareTo(value2);

                // 根据排序方向反转比较结果
                return sortItem.getDirection() == SortDirection.DESC ? -compareResult : compareResult;
            } catch (Exception e) {
                throw new RuntimeException("排序失败：属性[" + sortItem.getProperty() + "]不存在或无法访问", e);
            }
        };
    }

    // 排序方向枚举
    private enum SortDirection {
        ASC, DESC;

        public static SortDirection fromString(String directionStr) {
            return directionStr.equalsIgnoreCase("desc") ? DESC : ASC;
        }
    }

    // 排序项内部类，封装属性名和排序方向
    private static class SortItem {
        private final String property;
        private final SortDirection direction;

        public SortItem(String property, SortDirection direction) {
            this.property = property;
            this.direction = direction;
        }

        public String getProperty() { return property; }
        public SortDirection getDirection() { return direction; }
    }
}

使用示例 #

假设你有Student类：

public class Student {
    private String name;
    private String emailId;
    private Integer age;

    // 构造方法、getter和setter省略
    public String getName() { return name; }
    public String getEmailId() { return emailId; }
    public Integer getAge() { return age; }
}

调用排序方法：

List<Student> studentList = // 初始化你的学生列表
// 按name降序、age升序排序
GenericSortUtils.sort(studentList, "name: desc, age asc");

扩展说明 #

1. 性能优化：如果是高并发场景，可以缓存PropertyDescriptor，避免每次排序都反射获取getter方法
2. 自定义比较器：如果属性未实现Comparable，可以扩展方法允许传入属性对应的比较器
3. 异常处理：当前实现直接抛出运行时异常，你可以根据业务需求改为返回原列表或自定义异常
4. 依赖替代：如果项目中使用Spring，可以用BeanWrapper替代PropertyDescriptor，简化反射操作

内容的提问来源于stack exchange，提问作者Ajay Kumar