动态查找表示原始 Java 类型的类

Question

我需要在 Java 中进行一些反射方法调用。这些调用将包括具有原始类型（int、double 等）参数的方法。反射性查找方法时指定此类类型的方式有 int.class、double.class 等。

挑战在于我正在接受来自外部源的输入，该输入将动态指定类型。因此，我还需要动态地提出这些类引用。想象一个带有参数类型列表的方法名称列表的分隔文件：

doSomething int double
doSomethingElse java.lang.String boolean

如果输入类似于java.lang.String，我知道我可以将Class.forName("java.lang.String") 用于该类实例。有什么方法可以使用该方法或其他方法来获取原始类型 Classes 吗？

编辑： 感谢所有的受访者。显然没有内置的方法可以干净地做我想做的事，所以我将满足于重用 Spring 框架中的 ClassUtils 类。它似乎包含 Class.forName() 的替代品，可以满足我的要求。

Answer 1

原始类型的Class 实例可以按照您所说的使用例如int.class，但也可以使用 Integer.TYPE 之类的东西获得相同的值。每个原始包装类都包含一个静态字段TYPE，它具有相应的原始类实例。

您无法通过forName 获得原始类，但您可以从现成的类中获得它。如果你绝对必须使用反射，你可以尝试这样的事情：

Class clazz = Class.forName("java.lang.Integer");
Class intClass = clazz.getField("TYPE").get(null);

intClass.equals(int.class);         // => true

Answer 2

Spring 框架包含一个实用程序类ClassUtils，其中包含静态方法forName。此方法可用于您描述的确切目的。

如果你不喜欢依赖 Spring：source code of the method 可以在 e 中找到。 G。 here 在他们的公共存储库中。类源代码在 Apache 2.0 模型下获得许可。

但请注意，该算法使用原始类型的硬编码映射。

---

编辑：感谢评论者 Dávid Horváth 和 Patrick 指出损坏的链接。

Answer 3

您可能只需要映射原语，然后为其余的类执行“forName”方法：

我会这样做：

void someWhere(){
     String methodDescription = "doSomething int double java.lang.Integer java.lang.String"
     String [] parts = methodDescription.split();
     String methodName= parts[0]
     Class [] paramsTypes = getParamTypes( parts ); // Well, not all the array, but a, sub array from 1 to arr.length..  

    Method m = someObject.class.getMethod( methodName, paramTypes );
    etc. etc etc.
}

public Class[] paramTypes( String [] array ){
     List<Class> list = new ArrayList<Class>();
     for( String type : array ) {
         if( builtInMap.contains( type )) {
             list.add( builtInMap.get( type ) );
          }else{
             list.add( Class.forName( type ) );
          }
     }
     return list.toArray();
}  

    // That's right.
Map<String,Class> builtInMap = new HashMap<String,Class>();{
       builtInMap.put("int", Integer.TYPE );
       builtInMap.put("long", Long.TYPE );
       builtInMap.put("double", Double.TYPE );
       builtInMap.put("float", Float.TYPE );
       builtInMap.put("bool", Boolean.TYPE );
       builtInMap.put("char", Character.TYPE );
       builtInMap.put("byte", Byte.TYPE );
       builtInMap.put("void", Void.TYPE );
       builtInMap.put("short", Short.TYPE );
}

也就是说，创建一个存储基元类型的映射，如果描述属于基元，则使用映射类。此映射也可以从外部配置文件加载，以增加灵活性，因此您可以将 String 添加为内置而不是 java.lang.String 或可能具有这样的方法。

"doSomething 字符串是|否"

在 Struts、Hibernate、Spring 和 Apache libs 等 OS 项目中有大量此类代码（仅举几例），因此您无需从零开始。

顺便说一句。我没有编译上面的代码，但我很确定它只需稍加修改就可以工作，不要投反对票。

Answer 4

Apache Commons Lang 有ClassUtils.getClass(String)，支持原始类型。

Answer 5

不幸的是，许多 Class 方法不能以一致的方式处理原语。在 forName 中解决这个问题的一个常见方法是有一个类似的表；

private static final Map<String, Class> BUILT_IN_MAP = 
    new ConcurrentHashMap<String, Class>();

static {
    for (Class c : new Class[]{void.class, boolean.class, byte.class, char.class,  
            short.class, int.class, float.class, double.class, long.class})
        BUILT_IN_MAP.put(c.getName(), c);
}

public static Class forName(String name) throws ClassNotFoundException {
    Class c = BUILT_IN_MAP.get(name);
    if (c == null)
        // assumes you have only one class loader!
        BUILT_IN_MAP.put(name, c = Class.forName(name));
    return c;
}

Answer 6

以下代码讨论了如何获取字段名称已知的原始类型的类，例如在本例中为“sampleInt”。

public class CheckPrimitve {
    public static void main(String[] args) {
        Sample s = new Sample();
        try {
            System.out.println(s.getClass().getField("sampleInt").getType() == int.class); // returns true
            System.out.println(s.getClass().getField("sampleInt").getType().isPrimitive()); // returns true
        } catch (NoSuchFieldException e) {          
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        }       
    }
}

class Sample {
    public int sampleInt;
    public Sample() {
        sampleInt = 10;
    }
}

还可以通过获取给定值的相应包装类或其字段值来检查给定值是否为原始值。

    public class CheckPrimitve {
        public static void main(String[] args) {
            int i = 3;
            Object o = i;
            System.out.println(o.getClass().getSimpleName().equals("Integer")); // returns true
            Field[] fields = o.getClass().getFields();
            for(Field field:fields) {
                System.out.println(field.getType()); // returns {int, int, class java.lang.Class, int}
            }
        }
    }

Answer 7

Google Guava 为这类东西提供com.google.common.primitives.Primitives。

Answer 8

您可以使用此代码:)

/**
 * Get an array class of the given class.
 *
 * @param klass to get an array class of
 * @param <C>   the targeted class
 * @return an array class of the given class
 */
public static <C> Class<C[]> arrayClass(Class<C> klass) {
    return (Class<C[]>) Array.newInstance(klass, 0).getClass();
}

/**
 * Get the class that extends {@link Object} that represent the given class.
 *
 * @param klass to get the object class of
 * @return the class that extends Object class and represent the given class
 */
public static Class<?> objectiveClass(Class<?> klass) {
    Class<?> component = klass.getComponentType();
    if (component != null) {
        if (component.isPrimitive() || component.isArray())
            return Reflect.arrayClass(Reflect.objectiveClass(component));
    } else if (klass.isPrimitive()) {
        if (klass == char.class)
            return Character.class;
        if (klass == int.class)
            return Integer.class;
        if (klass == boolean.class)
            return Boolean.class;
        if (klass == byte.class)
            return Byte.class;
        if (klass == double.class)
            return Double.class;
        if (klass == float.class)
            return Float.class;
        if (klass == long.class)
            return Long.class;
        if (klass == short.class)
            return Short.class;
    }

    return klass;
}

/**
 * Get the class that don't extends {@link Object} from the given class.
 *
 * @param klass to get the non-object class of
 * @return the non-object class of the given class
 * @throws IllegalArgumentException when the given class don't have a primitive type
 */
public static Class<?> primitiveClass(Class<?> klass) {
    if (klass == Character.class)
        return char.class;
    if (klass == Integer.class)
        return int.class;
    if (klass == Boolean.class)
        return boolean.class;
    if (klass == Byte.class)
        return byte.class;
    if (klass == Double.class)
        return double.class;
    if (klass == Float.class)
        return float.class;
    if (klass == Long.class)
        return long.class;
    if (klass == Short.class)
        return short.class;

    throw new IllegalArgumentException(klass + " don't have a primitive type");
}