Простой способ получить тип класса-оболочки в Java

Ответ 1

Я использую библиотеку Google Collections в своем ответе, потому что я так избалован, но вы можете, вероятно, увидеть, как это сделать с простыми HashMaps.

  // safe because both Long.class and long.class are of type Class<Long>
  @SuppressWarnings("unchecked")
  private static <T> Class<T> wrap(Class<T> c) {
    return c.isPrimitive() ? (Class<T>) PRIMITIVES_TO_WRAPPERS.get(c) : c;
  }

  private static final Map<Class<?>, Class<?>> PRIMITIVES_TO_WRAPPERS
    = new ImmutableMap.Builder<Class<?>, Class<?>>()
      .put(boolean.class, Boolean.class)
      .put(byte.class, Byte.class)
      .put(char.class, Character.class)
      .put(double.class, Double.class)
      .put(float.class, Float.class)
      .put(int.class, Integer.class)
      .put(long.class, Long.class)
      .put(short.class, Short.class)
      .put(void.class, Void.class)
      .build();

Странно, что в JDK для этого ничего не существует, но на самом деле ничего не происходит.

РЕДАКТИРОВАТЬ: Я полностью забыл, что мы выпустили это:

http://google.github.io/guava/releases/21.0/api/docs/com/google/common/primitives/Primitives.html

У него есть метод wrap(), плюс unwrap() и несколько других случайных вещей.

Ответ 2

Apache Commons Lang имеет полезный метод для этого (ClassUtils. primitiveToWrapper()), который будет таким же уродливым под обложками, но по крайней мере вы можете притвориться, что это приятно.

Ответ 3

Вот другой способ, если вам не нужен высоко оптимизированный код:

    Class<?> primitive=long.class;
    Class<?> boxed=Array.get(Array.newInstance(primitive,1),0).getClass();
    System.out.println(primitive.getName());
    System.out.println(boxed.getName());

(Редактирование/добавление объяснения)

Сначала нужно было посмотреть, есть ли в Java метод, который дает вам класс-оболочку, когда ему присваивается примитивный тип. Не могу найти ни одного.

Затем нужно было увидеть, можно ли в Java создать примитивное значение, когда задают примитивный тип (тогда вы можете каким-то образом получить объект из него). Не могу найти способ сделать это.

Но затем выяснилось, что вы МОЖЕТе Java создать массив примитивных значений, если ему дан примитивный тип. И затем есть метод Java, который дает вам объект типа обертки элемента массива (который является примитивным). Как только у вас есть объект, вы можете получить тип.

Так вот как все это работает:

Метод Array.newInstance() создает массив любого типа, который вы укажете, будь то примитив или объект. В случае объекта все элементы имеют тип объекта, но инициализируются нулем. В случае примитива элементы имеют примитивный тип. Но элемент переменной/массива примитива не может быть нулевым, поэтому он имеет значение по умолчанию типа примитива, например, int будет нулевым. Таким образом, никакие элементы не будут нулевыми. И теперь, если вы попытаетесь получить значение элемента с помощью Array.get(), у Array.get() не останется иного выбора, как пометить это примитивное значение для объекта, например, int для Integer, потому что Array.get() может ' t вернуть примитивное значение. Теперь у вас есть объект типа бокса (обтекания) вашего оригинального примитивного типа. Наконец, вызов Object.getClass() дает вам тип упаковки (обтекания).

Этот прием работает с любым примитивным типом, который есть у вас в Java сегодня и в будущем.

Ответ 4

Вы можете вызвать class.isPrimitive(), чтобы узнать, является ли он примитивным или нет, однако нет метода бокса для преобразования классов в JDK. Существует по крайней мере одна открытая ошибка, связанная с этим.

Ответ 5

(Идея) Получить имя класса и сделать его заглавной, а затем вызвать Class.forInstance(className).newInstance (примитив). Исключения составляют "char" → Character и "int" → Integer

                                Class c=Primitive class object
                                if (c.isPrimitive()) {
                                    if (c == char.class) {
                                        Object wrapper=new Character(primitive var);
                                    }
                                    if (c == int.class) {
                                        Object wrapper=new Integer(primitive var);
                                    }
                                    else {
                                        String name=c.getName();
                                        try {
                                            Class<?> c2=Class.forName("java.lang."+name.substring(0,1).toUpperCase()+name.substring(1,name.length()));
                                            Object wrapper=c2.getConstructor(c).newInstance(primitve_var);
                                        } catch (ClassNotFoundException ex) {
                                            System.out.println("RROR");
                                        }
                                    }

                                }

Ответ 6

Class<?> toWrapper(Class<?> clazz) {
    if (!clazz.isPrimitive())
        return clazz;

    if (clazz == Integer.TYPE)
        return Integer.class;
    if (clazz == Long.TYPE)
        return Long.class;
    if (clazz == Boolean.TYPE)
        return Boolean.class;
    if (clazz == Byte.TYPE)
        return Byte.class;
    if (clazz == Character.TYPE)
        return Character.class;
    if (clazz == Float.TYPE)
        return Float.class;
    if (clazz == Double.TYPE)
        return Double.class;
    if (clazz == Short.TYPE)
        return Short.class;
    if (clazz == Void.TYPE)
        return Void.class;

    return clazz;
}

Ответ 7

Там также com.sun.beans.finder.PrimitiveWrapperMap # getType (primitiveName). Но, конечно, использование классов из пакета "com.sun" на самом деле не рекомендуется...

Ответ 8

Итак, вы хотите получить тип класса оболочки, хорошо.

конспект

Мы извлекаем поле и затем обнаруживаем, что оно содержит примитивный тип.

Field f = getTheField(); // Dummy method that returns my Field
Class<?> c = f.getType();

Но вместо этого нам нужен тип оболочки.

Примитивные типы в Java

Теперь, как вы уже узнали, единственное, для чего хорош примитивный класс, - это возвращать true для c.isPrimitive(); ,

Из вики-книг - Java-программирование:

Примитивные типы - это самые основные типы данных, доступные на языке Java. Есть 8: логическое значение, байт, тип char, short, int, long, float и double. Эти типы служат строительными блоками манипулирования данными в Java. Такие типы служат только одной цели - содержат чистые, простые значения вида.

Попытка использовать их любым другим способом, и вы получите много боли.

Невозможно создать новый экземпляр примитива.

Field f = getTheField();
Class<?> c = f.getType();
Object wrapper = c.newInstance();
//  java.lang.InstantiationException thrown: int
//        at Class.newInstance (Class.java:545) 

Невозможно привести к примитивному типу.

Field f = getTheField();
Class<?> c = f.getType();
Object wrapper = c.cast(0);
//  java.lang.ClassCastException thrown: Cannot cast java.lang.Integer to int
//        at Class.cast (Class.java:3578)

Можно привести к пустому типу оболочки. Да уж! \О/

Field f = getTheField();
Class<?> c = f.getType();
Object wrapper = c.cast(null);

Нет исключений, и переменная wrapper имеет тип class java.lang.Integer но со значением null, много хорошего, что нам пригодится.

Примитивы даже не наследуются от оболочек.

boolean isSuperClass = Integer.class.isAssignableFrom(int.class); // false

Это, очевидно, ни к чему нас не приведет, давайте вернемся назад к проблеме и посмотрим на картину в целом.

Когда сначала у тебя ничего не получится...

Напомним: мы извлекаем поле, которое должно быть откуда-то, поскольку java.lang.reflect.Field помечен как final и не предоставляет открытых конструкторов.

Если бы мы заполнили пробелы, это могло бы выглядеть примерно так.

public class Simple {
    public static int field;

    public static void main(String[] args) {
        Field f = Simple.class.getField("field"); // Actual method that returns my Field
        Class<?> c = f.getType();
    }
}

Вместо того, чтобы бороться с машиной, давайте лучше работать с ней. Одним из преимуществ примитивов является то, что они будут инициализироваться значением по умолчанию 0 вместо null. Посмотрим, сможем ли мы это использовать.

Получить класс-оболочку из обернутого экземпляра.

public class Simple {
    public static int field;

    public static void main(String[] args) {
        Simple boxer = new Simple();
        Field f = Simple.class.getField("field");
        Object wrapped = f.get(null);    // Integer value 0
        Class<?> c = wrapped.getClass(); // class java.lang.Integer
    }
}

Это было намного проще, чем раньше, и нам даже ничего не нужно было делать, все было сделано для нас. Еще один плюс для того, чтобы не пытаться идти против течения.

Давайте улучшим это, сделаем рефакторинг и сделаем его более пригодным для повторного использования, извлекая метод.

Реализуйте метод ручного бокса.

public class Simple {
    public static int field;

    public static <T> T wrap(T t) {
        return t;
    }

    public static void main(String[] args) {
        Field f = Simple.class.getField("field");
        Class<?> c = Simple.wrap(f.get(null)).getClass(); // class java.lang.Integer
    }
}

Простая примитивная переноска без необходимости просматривать типы или использовать таблицы поиска, потому что Java все равно это делает.

Простое решение

Field f = getTheField(); // Dummy method that returns my Field
Class<?> c = f.get(null).getClass(); 

Или вы можете заменить null на экземпляр, если поле не является статическим.

NJoy!