Определение примитивного типа объекта

У меня есть Object[]массив, и я пытаюсь найти примитивы. Пробовал пользоваться Class.isPrimitive(), но вроде что-то не так делаю:

int i = 3;
Object o = i;

System.out.println(o.getClass().getName() + ", " +
                   o.getClass().isPrimitive());

печатает java.lang.Integer, false.

Есть ли правильный путь или какая-то альтернатива?

Типы в Object[]объекте никогда не будут примитивными - потому что у вас есть ссылки! Здесь тип iявляется в intто время как тип объекта , на который ссылается oэто Integer(из - за авто-бокс).

Похоже, вам нужно выяснить, является ли тип «оболочкой для примитива». Я не думаю, что для этого есть что-то встроенное в стандартные библиотеки, но это легко кодировать:

import java.util.*;

public class Test
{
    public static void main(String[] args)        
    {
        System.out.println(isWrapperType(String.class));
        System.out.println(isWrapperType(Integer.class));
    }

    private static final Set<Class<?>> WRAPPER_TYPES = getWrapperTypes();

    public static boolean isWrapperType(Class<?> clazz)
    {
        return WRAPPER_TYPES.contains(clazz);
    }

    private static Set<Class<?>> getWrapperTypes()
    {
        Set<Class<?>> ret = new HashSet<Class<?>>();
        ret.add(Boolean.class);
        ret.add(Character.class);
        ret.add(Byte.class);
        ret.add(Short.class);
        ret.add(Integer.class);
        ret.add(Long.class);
        ret.add(Float.class);
        ret.add(Double.class);
        ret.add(Void.class);
        return ret;
    }
}

commons-lang ClassUtils имеет соответствующие методы .

В новой версии есть:

boolean isPrimitiveOrWrapped = 
    ClassUtils.isPrimitiveOrWrapper(object.getClass());

В старых версиях есть wrapperToPrimitive(clazz)метод, возвращающий примитивное соответствие.

boolean isPrimitiveOrWrapped = 
    clazz.isPrimitive() || ClassUtils.wrapperToPrimitive(clazz) != null;

Библиотека гуавы Google, имеет утилиту Primitives , что проверить , если класс является типом оболочкой для примитивного: Primitives.isWrapperType(class).

Class.isPrimitive () работает для примитивов

Для любителей лаконичного кода.

private static final Set<Class> WRAPPER_TYPES = new HashSet(Arrays.asList(
    Boolean.class, Character.class, Byte.class, Short.class, Integer.class, Long.class, Float.class, Double.class, Void.class));
public static boolean isWrapperType(Class clazz) {
    return WRAPPER_TYPES.contains(clazz);
}

Начиная с Java 1.5 и выше, появилась новая функция, называемая автоматическим боксом. Компилятор делает это сам. Когда он видит возможность, он преобразует примитивный тип в соответствующий класс-оболочку.

Вероятно, здесь происходит, когда вы объявляете

Object o = i;

Компилятор скомпилирует этот оператор как

Object o = Integer.valueOf(i);

Это автобокс. Это объяснило бы результат, который вы получаете. На этой странице из спецификации Java 1.5 более подробно объясняется автоматическая упаковка.

Integerне примитив, Class.isPrimitive()не врет.

Думаю это происходит из -за автобокса .

int i = 3;
Object o = i;
o.getClass().getName(); // prints Integer

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

public static boolean isWrapperType(Class<?> clazz) {
    return clazz.equals(Boolean.class) || 
        clazz.equals(Integer.class) ||
        clazz.equals(Character.class) ||
        clazz.equals(Byte.class) ||
        clazz.equals(Short.class) ||
        clazz.equals(Double.class) ||
        clazz.equals(Long.class) ||
        clazz.equals(Float.class);
}

Вам придется иметь дело с автобоксом java.
Возьмем код

общедоступный тест
{
    public static void main (String [] args)
    {
        int я = 3;
        Объект o = i;
        возвращение;
    }
}

Скомпилировано из "test.java"
открытый класс test расширяет java.lang.Object {
публичный тест ();
  Код:
   0: aload_0
   1: invokespecial # 1; // Метод java / lang / Object. "" :() V
   4: возврат


public static void main (java.lang.String []);
  Код:
   0: iconst_3
   1: istore_1
   2: iload_1
   3: invokestatic # 2; // Метод java / lang / Integer.valueOf: (I) Ljava / lang / Integer;
   6: astore_2
   7: возврат

}

invokestatic # 2; // Метод java / lang / Integer.valueOf: (I) Ljava / lang / Integer;

public static boolean isValidType(Class<?> retType)
{
    if (retType.isPrimitive() && retType != void.class) return true;
    if (Number.class.isAssignableFrom(retType)) return true;
    if (AbstractCode.class.isAssignableFrom(retType)) return true;
    if (Boolean.class == retType) return true;
    if (Character.class == retType) return true;
    if (String.class == retType) return true;
    if (Date.class.isAssignableFrom(retType)) return true;
    if (byte[].class.isAssignableFrom(retType)) return true;
    if (Enum.class.isAssignableFrom(retType)) return true;
    return false;
}

Просто чтобы вы могли видеть, что isPrimitive может вернуть true (поскольку у вас достаточно ответов, показывающих, почему это false):

public class Main
{
    public static void main(final String[] argv)
    {
        final Class clazz;

        clazz = int.class;
        System.out.println(clazz.isPrimitive());
    }
}

Это имеет значение при отражении, когда метод принимает "int", а не "Integer".

Этот код работает:

import java.lang.reflect.Method;

public class Main
{
    public static void main(final String[] argv)
        throws Exception
    {
        final Method method;

        method = Main.class.getDeclaredMethod("foo", int.class);
    }

    public static void foo(final int x)
    {
    }
}

Этот код не работает (не удается найти метод):

import java.lang.reflect.Method;

public class Main
{
    public static void main(final String[] argv)
        throws Exception
    {
        final Method method;

        method = Main.class.getDeclaredMethod("foo", Integer.class);
    }

    public static void foo(final int x)
    {
    }
}

Как уже говорили несколько человек, это связано с автобоксом .

Вы могли бы создать служебный метод , чтобы проверить , является ли класс объекта Integer, Doubleи т.д. Но нет никакого способа узнать , был ли объект , созданный Autoboxing примитива ; после упаковки он выглядит как явно созданный объект.

Поэтому, если вы точно не знаете, что ваш массив никогда не будет содержать класс-оболочку без автобокса, настоящего решения нет.

Типы-оболочки primitve не будут реагировать на это значение. Это для представления примитивов классом, хотя, помимо отражения, я не могу придумать слишком много применений для него сразу. Так, например

System.out.println(Integer.class.isPrimitive());

печатает "ложь", но

public static void main (String args[]) throws Exception
{
    Method m = Junk.class.getMethod( "a",null);
    System.out.println( m.getReturnType().isPrimitive());
}

public static int a()
{
    return 1;
}

печатает "правда"

Я опаздываю на выставку, но если вы тестируете поле, вы можете использовать getGenericType:

import static org.junit.Assert.*;

import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;

import org.junit.Test;

public class PrimitiveVsObjectTest {

    private static final Collection<String> PRIMITIVE_TYPES = 
            new HashSet<>(Arrays.asList("byte", "short", "int", "long", "float", "double", "boolean", "char"));

    private static boolean isPrimitive(Type type) {
        return PRIMITIVE_TYPES.contains(type.getTypeName());
    }

    public int i1 = 34;
    public Integer i2 = 34;

    @Test
    public void primitive_type() throws NoSuchFieldException, SecurityException {
        Field i1Field = PrimitiveVsObjectTest.class.getField("i1");
        Type genericType1 = i1Field.getGenericType();
        assertEquals("int", genericType1.getTypeName());
        assertNotEquals("java.lang.Integer", genericType1.getTypeName());
        assertTrue(isPrimitive(genericType1));
    }

    @Test
    public void object_type() throws NoSuchFieldException, SecurityException {
        Field i2Field = PrimitiveVsObjectTest.class.getField("i2");
        Type genericType2 = i2Field.getGenericType();
        assertEquals("java.lang.Integer", genericType2.getTypeName());
        assertNotEquals("int", genericType2.getTypeName());
        assertFalse(isPrimitive(genericType2));
    }
}

В документации Oracle перечислены 8 примитивных типов.

Это самый простой способ, который я мог придумать. Классы-оболочки присутствуют только в java.langпакете. И кроме классов-оболочек, ни один другой класс не java.langимеет поля с именем TYPE. Вы можете использовать это, чтобы проверить, является ли класс классом Wrapper или нет.

public static boolean isBoxingClass(Class<?> clazz)
{
    String pack = clazz.getPackage().getName();
    if(!"java.lang".equals(pack)) 
        return false;
    try 
    {
        clazz.getField("TYPE");
    } 
    catch (NoSuchFieldException e) 
    {
        return false;
    }           
    return true;        
}

Получите BeanUtils из Spring http://static.springsource.org/spring/docs/3.0.x/javadoc-api/

Вероятно, вариант Apache (commons beans) имеет аналогичную функциональность.

вы можете определить, является ли объект типом оболочки, с помощью следующих операторов:

***objClass.isAssignableFrom(Number.class);***

и вы также можете определить примитивный объект с помощью метода isPrimitive ()

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

Output:
true
int
int
class java.lang.Class
int

Для пользователей javapoet также есть такой способ:

private boolean isBoxedPrimitive(Class<?> type) {
    return TypeName.get(type).isBoxedPrimitive();
}