char[]到方法参数的java类的完整量化名称

java中的反射问题

样本类

Class Question{
        public  int a   ( String a, char[] c,int b) { return  b; }    
}

方法通过反射获取具有名称和参数的方法

 public Method getMethodWithParams(Class<?> klasa, String methodName, Class<?>[] params) throws
            SecurityException, NoSuchMethodException {
       Class<?>[] primitivesToWrappers =
                  ClassUtils.primitivesToWrappers(params);
        Method publicMethod = MethodUtils.getMatchingAccessibleMethod(klasa,
                                                                      methodName,
                                                                      primitivesToWrappers );
        System.out.println(publicMethod.toGenericString());

        return publicMethod;
    }

 private void printParams(Type[] types) throws ClassNotFoundException {

        for (Type genericParameterType : types) {
            System.out.println(genericParameterType.toString());

        }

    }

公共方法getMethodWithParams（类klasa，字符串methodName，类[]params）抛出
SecurityException，NoSuchMethodException{
类[]基本类=
原始说唱人（params）；
方法publicMethod=MethodUtils.getMatchingAccessibleMethod（klasa，
方法名，
原始说唱歌手）；
System.out.println（publicMethod.toGenericString（））；
返回法；
}
私有void printParams（类型[]类型）引发ClassNotFoundException{
对于（类型genericParameterType:types）{
System.out.println（genericParameterType.toString（））；
}
}

主程序

Question cls = new Question();
    Class<?>[] paramString = new Class<?>[3];
            paramString[0] = String.class;
            paramString[1] = char[].class;
            paramString[2] = int.class;
     Method methodParams1 = getMethodParams(cls.getClass(),"a", paramString);
            System.out.println(methodParams1.getName());
            Type[] genericTypes = methodParams1.getParameterTypes();
            printParams(genericTypes);

Question cls=新问题（）；
Class[]paramString=新类[3]；
paramString[0]=String.class；
paramString[1]=char[]类；
paramString[2]=int.class；
方法methodParams1=getMethodParams（cls.getClass（），“a”，paramString）；
System.out.println（methodParams1.getName（））；
类型[]genericTypes=methodParams1.getParameterTypes（）；
printParams（通用类型）；

输出为：

a

类java.lang.String

类别[C]

int

问题是下一次测试失败了

Character testCharacterObjArray = new Character[]
Class<?> aClass = ClassUtils.getClass("[C", true);
Assert.assertEquals(testCharacterObjArray.getClass(), aClass);

Character testCharacterObjArray=新字符[]
类aClass=ClassUtils.getClass（“[C”，true）；
Assert.assertEquals（testCharacterObjArray.getClass（），aClass）；

ClassUtils来自org.apache.commons.lang3

查找库以获取“[Ljava.lang.Character；”而不是“[C”，因为它显示为ClassUtils.primitiveStowrapers（）失败

解决方案基于：

public类convertStringToClass（String str）抛出
ClassNotFoundException{
Class aClass=ClassUtils.getClass（str，true）；
if（aClass.isArray（））{
类原语说话者=
primitiveToRapper（aClass.getComponentType（））；
Object newInstance=Array.newInstance（PrimitiveToRapper，0）；
System.out.println（“*****”+newInstance.getClass（）.getName（））；
返回ClassUtils。
getClass（newInstance.getClass（）.getName（），true）；
}
否则{
返回ClassUtils.primitiveToRapper（aClass）；
}
}

此操作失败的原因：

Character[] testCharacterObjArray = new Character[]
Class<?> aClass = ClassUtils.getClass("[C", true);
Assert.assertSame(testCharacterObjArray.getClass(), aClass);

Character[]testCharacterObjArray=新字符[]
类aClass=ClassUtils.getClass（“[C”，true）；
Assert.assertSame（testCharacterObjArray.getClass（），aClass）；

“[C”表示

char[]

而不是

Character[]

无法在

char[].class

上调用

ClassUtils.primitivesToWrappers（）

的原因是

char[]

不是一种基本类型

如果要将基元类数组映射到包装类数组，则：

使用

Class.isArray（）

测试类型是否为数组

使用

Class.getComponentType（）

获取基类型

如果基类型是基元，则映射它

使用

Arrays.newInstance（baseType，…）

创建一个数组，然后调用

getClass（）

来创建映射基类型的数组类型

---

恐怕你的问题不仅仅在于原始说唱歌手

另外，

getMatchingAccessibleMethod

并不像我预期的那样：

在Java中，我可以调用：

    new Question().foo("a", new char[] {'a'}, 1);
    new Question().foo("b", new char[] {'b'}, Integer.valueOf(2));

    new Question().bar("c", new char[] {'c'}, 3);
    new Question().bar("d", new char[] {'d'}, Integer.valueOf(4));

这会导致Java中的编译错误：

    new Question().foo("b", new char[] {'b'}, Integer.valueOf(2));

但在MethodUtils测试中：

    Method m1 = MethodUtils.getMatchingAccessibleMethod(Question.class, "foo", String.class, char[].class, int.class);
    System.out.println("m1:" + m1);
    Method m2 = MethodUtils.getMatchingAccessibleMethod(Question.class, "foo", String.class, char[].class, Integer.class);
    System.out.println("m2: " + m2);
    Method m3 = MethodUtils.getMatchingAccessibleMethod(Question.class, "foo", String.class, Character[].class, Integer.class);
    System.out.println("m3: " + m3);

    Method mb1 = MethodUtils.getMatchingAccessibleMethod(Question.class, "bar", String.class, char[].class, int.class);
    System.out.println("mb1: " +mb1);
    Method mb2 = MethodUtils.getMatchingAccessibleMethod(Question.class, "bar", String.class, char[].class, Integer.class);
    System.out.println("mb2:" + mb2);

输出是（我希望m2和mb1不为null）：

m1:public int-LangTest$Question.foo（java.lang.String，char[]，int）
m2:null
m3：空
mb1:null
mb2:public int LangTest$Question.bar（java.lang.String，char[]，java.lang.Integer）

我将您的问题类修改为：

static class Question {
    public  int foo( String a, char[] c,int b) { return  b; }
    public  int bar( String a, char[] c,Integer b) { return  b; }
}

---

我不理解这个测试，为什么你不想有TestPrimultObjs= char []类？（BTW，测试不能编译），这也是一个值得考虑的问题。

static class Question {
    public  int foo( String a, char[] c,int b) { return  b; }
    public  int bar( String a, char[] c,Integer b) { return  b; }
}