Question

想象一下，我有两个POJO bean：

public class Employee {
   private String name;
   private long id;
   ....
   //GETTERS AND SETTERS
}

public class Buildings {
   private String name;
   private long numOfEmployees;
   ...
   //GETTERS AND SETTERS
}

现在我制作了两个POJO列表（empList＆amp; bldList），我想使用Collections.sort这样对它们进行排序：

Collections.sort(empList , new Comparator<Employee>() {
       public int compare(Employee o1, Employee o2) {
         return o2.getId().compareTo(o1.getId());
       }
});

和另一个这样的排序：

Collections.sort(bldList, new Comparator<Buildings>() {
       public int compare(Buildings o1, Buildings o2) {
         return o2.getNumOfEmployees().compareTo(o1.getNumOfEmployees());
       }
});

现在而不是为此编写两次比较器，我想我找到了一个解决方案，我可以使用泛型并在方法中执行此操作，我想到的是一种类似于此的方法：

public <T> List<T> sortMyList(List<T> list){
   Collections.sort(list, new Comparator<T>() {
         public int compare(T o1, T o2) {
            // I don't know how to call the Building and Employee methods here so I just show it with "???"
            return o1.???.compareTo(o2.???);
          }
   });
}

如何让这种方法适合我？

Answer 1

让您的课程实施Comparable<T>。

class Employee implements Comparable<Employee>{

   //override compareTo()

}

同样适用于Buildings

然后使用Collections.sort(listOfEmployee);

Answer 2

您可以让您的POJO实施Comparable界面

Answer 3

普遍的共识是，实施Comparable是正确和最佳的方式。

我的回答是“可以做到”，而不是“如何让这种方法对我有用的”最佳实践？“

这个答案应该被视为学术（并且需要改进）而不是可实施的解决方案。

public <T> void sortMyList(List<T> list) {

    Collections.sort(list, new Comparator<T>() {
        Method theMethod = null;

        @Override
        public int compare(T o1, T o2) {
            if (theMethod == null) {
                Method[] methods = o1.getClass().getMethods(); //reflection
                for (Method m : methods) {
                    if ("long".equals(m.getReturnType().toString())) {
                        theMethod = m;
                        break;
                    }
                }
            }
            try {
                return ((Long) (theMethod.invoke(o1, null))).compareTo((Long) (theMethod.invoke(o2, null)));
            } catch (Exception e) {
                e.printStackTrace();
            }
            return 0;
        }
    });
}

这假定在列表中找到的第一个返回long的方法用于比较。

获取Method的循环位于compare(T o1, T o2)，以避免getting the class of a generic type

等问题

Answer 4

另一种解决方案（比使用可比较的）

您可以在java中使用instanceof运算符。

示例：

public <T> List<T> sortMyList(List<T> list){
           Collections.sort(list, new Comparator<T>() {
           public int compare(T o1, T o2) {
                if(o1 instanceof Employee && o2 instanceof Employee)
                    return o2.getId().compareTo(o1.getId());
                else if(o1 instanceof Buildings && o2 instanceof Buildings)
                      return o2.getNumOfEmployees().compareTo(o1.getNumOfEmployees());
           }
  });
}

Java中的Java通用方法调用

4 个答案: