Java：排序列表<；列表<；T>&燃气轮机；基于特定指标

我正在编写排序列表>（使用泛型）的程序。但是，不确定如何在comparator中处理泛型数据类型

这是我到目前为止写的

public void sort(final int columnNumber){
    Collections.sort(this.listTable,new Comparator<List<T>>(){
        @Override
        public int compare(List<T> o1, List<T> o2) {
            int compareInt = 0;
            Object obj1 = o1.get(columnNumber);
            Object obj2 = o2.get(columnNumber);
            if(obj1.getClass().equals(obj2.getClass())){
                if(obj1.getClass().toString().endsWith(".String")){
                    compareInt = obj1.toString().compareTo(obj2.toString());
                }
                else if(obj1.getClass().toString().endsWith(".Integer")){
                    compareInt = (Integer)obj1 - (Integer)obj2;
                }
                else{
                    compareInt = obj1.toString().compareTo(obj2.toString());
                }

            }
            return compareInt;
        }
    });
}

public void排序（最终int列数）{
Collections.sort（this.listTable，newcomparator（））{
@凌驾
公共整数比较（列表o1，列表o2）{
int compareInt=0；
对象obj1=o1.get（列号）；
对象obj2=o2.get（columnNumber）；
如果（obj1.getClass（）.equals（obj2.getClass（）））{
if（obj1.getClass（）.toString（）.endsWith（“.String”））{
compareInt=obj1.toString（）.compareTo（obj2.toString（））；
}
else if（obj1.getClass（）.toString（）.endsWith（“.Integer”））{
compareInt=（整数）obj1-（整数）obj2；
}
否则{
compareInt=obj1.toString（）.compareTo（obj2.toString（））；
}
}
返回比较；
}
});
}

不要使用getClass（）.toString（）来比较类型。尽可能使用instanceof并尝试按公共接口对类型进行分组。例如，CharSequence是String、StringBuilder和StringBuffer的通用接口

这里有一个方法。您可能需要修改compare方法，以比较您拥有的任何类型，例如日期、URL或自定义对象

public class CompareEverything {

    public static void sort(List someList, int columnNumber) {
        Collections.sort(someList, new EverythingComparator(columnNumber));
    }

    public static class EverythingComparator implements Comparator<List<?>> {
        private int columnNumber;

        public EverythingComparator(int columnNumber) {
            this.columnNumber = columnNumber;
       }

        @Override
        public int compare(List<?> list1, List<?> list2) {
            Object obj1 = list1.get(columnNumber);
            Object obj2 = list2.get(columnNumber);
            return CompareEverything.compare(obj1, obj2);
       }
    }

    public static int compare(Object obj1, Object obj2) {
        int result = 0;
        if (obj1 == null) {
            result = (obj2 == null) ? 0 : -1;
        }
        else if (obj2 == null) {
            result = 1;
        }
        else if (obj1 instanceof CharSequence && obj2 instanceof CharSequence) {
            // String, StringBuilder, StringBuffer, etc.
            result = obj1.toString().compareTo(obj2.toString());
        }
        else if (obj1 instanceof Number && obj2 instanceof Number) {
            Number num1 = (Number)obj1;
            Number num2 = (Number)obj2;
            // Short, Integer, or Long
            if (isIntegral(obj1.getClass()) && isIntegral(obj2.getClass())) {
                result = Long.compare(num1.longValue(), num2.longValue());
            }
            else { // Float, Double, or any mismatched combo
                result = Double.compare(num1.doubleValue(), num2.doubleValue());
            }
        }
        // add other types...
        else {
            // mismatched types - compare as Strings
            // or maybe throw a RuntimeException?
           result = obj1.toString().compareTo(obj2.toString());
        }
        return result;
    }

    private static boolean isIntegral(Class<?> type) {
        return Short.class.equals(type) || Integer.class.equals(type) || Long.class.equals(type);
    }
}

公共类比较所有内容{
公共静态无效排序（列表someList，int columnNumber）{
排序（someList，new EverythingComparator（columnNumber））；
}
公共静态类EverythingComparator实现Comparator请告诉我们您的代码。这里没有任何研究工作。更糟糕的是，也没有问题。您处理泛型类型就像处理任何
对象一样谢谢。这非常有帮助。就像您使用CharSequence来处理各种类型的数据类型，如字符串、StringBuffer等，我有没有类似的类来处理与日期相关的类？
java.util.Date
是
java.sql.Date
和
Timestamp
等的父类。因此，如果（obj1 instanceof java.util.Date&&obj2 instanceof java.util.Date）{result=（（java.util.Date）obj1）。compareTo（obj2）；}
谢谢。因此，将来如果我要查找任何其他此类类，那么我应该查找所有此类类的父类？如果您可以通过比较基于公共父类的对象来避免重复代码，那么可以。