如何通过方法参数结合Java Lambda实现自定义列表排序？

没问题，这个需求完全可以用Java反射来实现，我来给你捋清楚怎么把固定的排序逻辑改成支持sortBy参数的动态版本。

核心思路 #

我们要根据传入的sortBy参数，动态找到ObjModel对应的Getter方法，把它转换成Comparator需要的Function，再用这个动态生成的Function来做排序。

完整代码实现 #

直接修改你的getLists方法就行，代码如下：

import java.lang.reflect.Method;
import java.util.Comparator;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

// 假设你的ObjModel类定义在这里
class ObjModel {
    private String modifiedtime;
    // 其他字段...
    
    public String getModifiedtime() {
        return modifiedtime;
    }
    // 其他Getter...
}

public class YourService {
    private List<ObjModel> lists;

    public void getLists(final String sortBy) {
        try {
            // 1. 根据sortBy拼接Getter方法名（遵循JavaBean规范：getXxx）
            String getterName = "get" + sortBy.substring(0, 1).toUpperCase() + sortBy.substring(1);
            // 2. 获取对应的Getter方法
            Method getterMethod = ObjModel.class.getMethod(getterName);
            
            // 3. 把反射调用转换成Comparator需要的Function
            Function<ObjModel, Comparable> sortFunction = obj -> {
                try {
                    // 调用Getter方法并返回结果，强制转成Comparable（因为排序需要可比较类型）
                    return (Comparable) getterMethod.invoke(obj);
                } catch (IllegalAccessException | InvocationTargetException e) {
                    // 这里可以根据业务需求处理异常，比如抛运行时异常或者返回默认值
                    throw new RuntimeException("Failed to get field value via reflection", e);
                }
            };
            
            // 4. 执行排序逻辑，和原来的写法一致，只是用动态生成的sortFunction
            lists = lists.stream()
                    .sorted(Comparator.comparing(sortFunction).reversed())
                    .collect(Collectors.toList());
        } catch (NoSuchMethodException e) {
            // 处理传入的sortBy没有对应Getter的情况
            throw new IllegalArgumentException("Invalid sort field: " + sortBy, e);
        }
    }
}

关键细节说明 #

• JavaBean规范适配：我们把sortBy参数的首字母大写，拼接成getXxx的形式，这是JavaBean的标准Getter命名规则，确保能正确找到方法。
• 异常处理：反射过程中可能出现找不到方法、无权访问、调用出错等异常，这里都做了捕获和包装，避免程序直接崩溃，同时给出明确的错误信息。
• Comparable强制转换：排序要求字段类型必须实现Comparable接口（比如String、Date、Integer这些默认都实现了），如果你的字段是自定义类型，记得让它实现Comparable，否则会抛出ClassCastException。

性能优化小技巧 #

如果这个方法会被频繁调用，反射的开销可能会有点大，你可以加个缓存来复用已经获取到的Method对象，避免每次都做反射查找：

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

public class YourService {
    private List<ObjModel> lists;
    // 用ConcurrentHashMap做线程安全的方法缓存
    private static final Map<String, Method> GETTER_METHOD_CACHE = new ConcurrentHashMap<>();

    public void getLists(final String sortBy) {
        try {
            // 先从缓存拿，没有再反射获取
            Method getterMethod = GETTER_METHOD_CACHE.computeIfAbsent(sortBy, key -> {
                try {
                    String getterName = "get" + key.substring(0, 1).toUpperCase() + key.substring(1);
                    return ObjModel.class.getMethod(getterName);
                } catch (NoSuchMethodException e) {
                    throw new IllegalArgumentException("Invalid sort field: " + key, e);
                }
            });
            
            // 后面的排序逻辑和之前一样
            Function<ObjModel, Comparable> sortFunction = obj -> {
                try {
                    return (Comparable) getterMethod.invoke(obj);
                } catch (IllegalAccessException | InvocationTargetException e) {
                    throw new RuntimeException("Failed to get field value via reflection", e);
                }
            };
            
            lists = lists.stream()
                    .sorted(Comparator.comparing(sortFunction).reversed())
                    .collect(Collectors.toList());
        } catch (IllegalArgumentException e) {
            throw e;
        }
    }
}

这样第一次调用后，后续再用同一个sortBy参数时，直接用缓存里的Method，性能会提升不少。

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