Java：转换基本类

Java中是否有一种简单的方法可以将基本类对象转换为对象类对象？给定一个类cl，我想把它转换成一个没有原语的类。例如

Class<?> cl = int.class;

...
if (cl.isPrimitive()) {
  cl = Object of primitive
}
...

Class cl=int.Class；
...
if（cl.isPrimitive（））{
cl=原语的对象
}
...

cl==Integer.class

我想要一个对所有基元类型都这样做的方法。显然，我可以遍历所有的基元类型，但我认为有人可能知道更好的解决方案

干杯，

---

麦克斯

希望我理解正确。基本上，您需要从基本类类型到它们的包装器方法的映射

在某些实用程序类中实现的静态实用程序方法将是一个优雅的解决方案，因为您将使用如下转换：

Class<?> wrapper = convertToWrapper(int.class);

Primitives.wrap(int.class); //returns Class<Integer>
Primitives.wrap(Integer.class); //returns Class<Integer>

Class包装器=convertToWrapper（int.Class）；

或者，声明并填充静态映射：

public final static Map<Class<?>, Class<?>> map = new HashMap<Class<?>, Class<?>>();
static {
    map.put(boolean.class, Boolean.class);
    map.put(byte.class, Byte.class);
    map.put(short.class, Short.class);
    map.put(char.class, Character.class);
    map.put(int.class, Integer.class);
    map.put(long.class, Long.class);
    map.put(float.class, Float.class);
    map.put(double.class, Double.class);
}

private Class<?> clazz = map.get(int.class);  // usage

public final static Map>Map=newhashmap>（）；
静止的{
map.put（boolean.class，boolean.class）；
map.put（byte.class，byte.class）；
map.put（short.class，short.class）；
map.put（char.class，Character.class）；
map.put（int.class，Integer.class）；
map.put（long.class，long.class）；
map.put（float.class，float.class）；
map.put（double.class，double.class）；
}
私有类clazz=map.get（int.Class）；//使用

org.apache.commons.lang.ClassUtils.primitiveToRapper（类）

或者，如果您正在使用，它有，您可以这样使用：

Class<?> wrapper = convertToWrapper(int.class);

Primitives.wrap(int.class); //returns Class<Integer>
Primitives.wrap(Integer.class); //returns Class<Integer>

Primitives.wrap（int.class）//返回类
wrap（Integer.class）//返回类

Guava和Apache Commons都使用底层的

HashMap>

，这并不是必需的，但有利于代码的可读性

• Commons Lang3实现：
• 番石榴的实施：

以下über优化代码段在固定时间内执行相同的功能，因为它通过索引查找映射到包装器类：

private static final Class[] wrappers = {
        Integer.class,
        Double.class,
        Byte.class,
        Boolean.class,
        Character.class,
        Void.class,
        Short.class,
        Float.class,
        Long.class
};

@SuppressWarnings("unchecked")
public static <T> Class<T> wrap(final Class<T> clazz) {
    if (!clazz.isPrimitive()) return clazz;
    final String name = clazz.getName();
    final int c0 = name.charAt(0);
    final int c2 = name.charAt(2);
    final int mapper = (c0 + c0 + c0 + 5) & (118 - c2);
    return (Class<T>) wrappers[mapper];
}

私有静态最终类[]包装={
Integer.class，
双层，
Byte.class，
Boolean.class，
人物，阶级，
空舱，
短小的，
浮动类，
长班
};
@抑制警告（“未选中”）
公共静态类包装（最终类包装）{
如果（！clazz.isPrimitive（））返回clazz；
最终字符串名=clazz.getName（）；
final int c0=name.charAt（0）；
最终int c2=name.charAt（2）；
最终整数映射器=（c0+c0+c0+5）和（118-c2）；
返回（类）包装器[mapper]；
}

---

这涉及到一些代码，所以除非您知道自己在做什么，否则不要对类进行重新排序；）

只需创建一个映射常量。我认为八个案子不值得麻烦是的。。。你说得对。反正我已经这么做了，只是觉得我可能会错过一个适合我的方法。是的，我就是这样做的。谢谢你，你忘了上课了。你能解释一下这个算法是如何工作的吗？它使用实际类名的两个字母来执行非常受限的索引查找。同样的算法也适用于将包装器转换为原语，唯一的区别是需要查找字母10和12（java.lang.prefix）。下面是更多的代码以及单元测试：