比较Java的泛型类型

我在比较泛型类型时遇到问题。在C中，我总是做一些类似的事情：

类元素，其中T:IComparable

---

我的问题是如何用java编写它？

我怀疑您想要的是：

class Element<T extends Comparable<T>>

类元素

---

。。。使用界面和一个。

希望它对其他人有帮助

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;

public class Comparator {
    public static HashMap<Class,Class> primitiveMap = new HashMap<Class,Class>() {{
        put(boolean.class,Boolean.class);
        put(byte.class,Byte.class);
        put(char.class,Character.class);
        put(short.class,Short.class);
        put(int.class,Integer.class);
        put(long.class,Long.class);
        put(float.class,Float.class);
        put(double.class,Double.class);
        put(String.class,String.class);
        put(Boolean.class,Boolean.class);
        put(Byte.class,Byte.class);
        put(Character.class,Character.class);
        put(Short.class,Short.class);
        put(Integer.class,Integer.class);
        put(Long.class,Long.class);
        put(Float.class,Float.class);
        put(Double.class,Double.class);
        put(Number.class, Number.class);
    }};
    
    private static int compare(Class<?> returnType,Object a, Object b) {
        if(returnType == String.class) {
            return ((String)a).compareTo((String)b);
        } else if(returnType == Short.class) {
            return ((Short)a).compareTo((Short)b);
        } else if(returnType == Integer.class) {
            return ((Integer)a).compareTo((Integer)b);
        } else if(returnType == Long.class) {
            return ((Long)a).compareTo((Long)b);
        } else if(returnType == Float.class) {
            return ((Float)a).compareTo((Float)b);
        } else if(returnType == Double.class) {
            return ((Double)a).compareTo((Double)b);
        }
        return 0;
    }
    public static <T> void sortAscending(ArrayList<T> list,Method m) {
        Class<?> returnType = primitiveMap.get(m.getReturnType());
        Collections.sort(list,(a,b) -> {
            try {
                return compare(returnType,m.invoke(a),m.invoke(b));
            } catch(Exception e) {
                System.out.println("Exception occured"+e.getMessage());
            }
            return 0;
        });
    }
    public static <T> void sortDescending(ArrayList<T> list,Method m) {
        Class<?> returnType = primitiveMap.get(m.getReturnType());
        Collections.sort(list,(a,b) -> {
            try {
                return compare(returnType,m.invoke(b),m.invoke(a));
            } catch(Exception e) {
                System.out.println("Exception occured"+e.getMessage());
            }
            return 0;
        });
    }
}

import java.lang.reflect.Method；
导入java.util.ArrayList；
导入java.util.Collections；
导入java.util.HashMap；
导入java.lang.reflect.Method；
导入java.util.ArrayList；
导入java.util.Collections；
导入java.util.HashMap；
公共类比较器{
publicstatichashmap primitiveMap=newhashmap（）{{
put（boolean.class，boolean.class）；
put（byte.class，byte.class）；
put（char.class，Character.class）；
put（short.class，short.class）；
put（int.class，Integer.class）；
put（long.class，long.class）；
put（float.class，float.class）；
put（双级，双级）；
put（String.class，String.class）；
put（Boolean.class，Boolean.class）；
put（Byte.class，Byte.class）；
put（字符.类，字符.类）；
put（Short.class，Short.class）；
put（Integer.class，Integer.class）；
put（Long.class，Long.class）；
put（Float.class，Float.class）；
put（双级，双级）；
put（Number.class，Number.class）；
}};
私有静态int比较（类returnType、对象a、对象b）{
if（returnType==String.class）{
返回（（字符串）a），与（（字符串）b）进行比较；
}else if（returnType==Short.class）{
返回（（短）a）。与（（短）b）比较；
}else if（returnType==Integer.class）{
返回（（整数）a），比较（（整数）b）；
}else if（returnType==Long.class）{
返回（（长）a）。与（（长）b）相比；
}else if（returnType==Float.class）{
返回（（浮动）a）。与（（浮动）b）比较；
}else if（returnType==Double.class）{
返回（（双）a）。与（（双）b）比较；
}
返回0；
}
公共静态无效排序（ArrayList列表，方法m）{
类returnType=primitiveMap.get（m.getReturnType（））；
集合。排序（列表，（a，b）->{
试一试{
返回比较（returnType，m.invoke（a），m.invoke（b））；
}捕获（例外e）{
System.out.println（“发生异常”+e.getMessage（））；
}
返回0；
});
}
公共静态void排序下降（ArrayList列表，方法m）{
类returnType=primitiveMap.get（m.getReturnType（））；
集合。排序（列表，（a，b）->{
试一试{
返回比较（returnType，m.invoke（b），m.invoke（a））；
}捕获（例外e）{
System.out.println（“发生异常”+e.getMessage（））；
}
返回0；
});
}
}

用于

import java.util.ArrayList;

public class Roommates {
    private String name;
    private int age;
    public Roommates(String name,int age) {
        this.name=name;
        this.age=age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public String toString() {
        return "name="+name+" age="+age;
    }
    
    public static void main(String...strings)throws Exception {
        ArrayList<Roommates> list = new ArrayList<Roommates>();
        list.add(new Roommates("Siva",31));
        list.add(new Roommates("Prabu",25));
        list.add(new Roommates("Suresh",55));
        list.add(new Roommates("Raghav",23));
        list.add(new Roommates("Suganthan",27));
        list.add(new Roommates("Vijay",34));
        
        Comparator.sortDescending(list,Roommates.class.getDeclaredMethod("getName"));
        System.out.println(list);
        
        Comparator.sortAscending(list,Roommates.class.getDeclaredMethod("getAge"));
        System.out.println(list);
    }
}

导入java.util.ArrayList；
公课室友{
私有字符串名称；
私人互联网；
公共室友（字符串名称，整数）{
this.name=name；
这个。年龄=年龄；
}
公共字符串getName（）{
返回名称；
}
公共整数getAge（）{
回归年龄；
}
公共字符串toString（）{
返回“name=“+name+”age=“+age；
}
公共静态void main（字符串…字符串）引发异常{
ArrayList=新建ArrayList（）；
增加（新室友（“湿婆”，31））；
添加（新室友（“Prabu”，25））；
添加（新室友（“Suresh”，55））；
添加（新室友（“Raghav”，23））；
添加（新室友（“Suganthan”，27））；
添加（新室友（“Vijay”，34））；
Comparator.sortdescenting（list，Roommates.class.getDeclaredMethod（“getName”））；
系统输出打印项次（列表）；
比较。排序（列表，室友。类。getDeclaredMethod（“getAge”）；
系统输出打印项次（列表）；
}
}

…为了帮助下一个人，您需要调用.compareTo（）（），而不是使用运算符。我很好奇为什么类实现Comparable不能正确地用于泛型类型，而类却可以。你能解释一下吗？感谢you@Mushy当前位置不清楚你的意思——“不能正常工作”太含糊了。我想你应该问一个新的非常具体的问题。