Determinar si un objeto es de tipo primitivo

Tengo una Object[]matriz y estoy tratando de encontrar las que son primitivas. He intentado usar Class.isPrimitive(), pero parece que estoy haciendo algo mal:

int i = 3;
Object o = i;

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

impresiones java.lang.Integer, false.

¿Existe una forma correcta o alguna alternativa?

Los tipos en an Object[]nunca serán realmente primitivos, ¡porque tienes referencias! Aquí el tipo de ies intmientras que el tipo de objeto al que se hace referencia oes Integer(debido al auto-boxing).

Parece que necesita averiguar si el tipo es un "contenedor de primitivo". No creo que haya nada integrado en las bibliotecas estándar para esto, pero es fácil de codificar:

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 tiene métodos relevantes .

La nueva versión tiene:

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

Las versiones antiguas tienen wrapperToPrimitive(clazz)método, que devolverá la correspondencia primitiva .

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

Guayaba biblioteca de Google tiene una utilidad Primitives ese cheque si una clase es un tipo de contenedor para una primitiva: Primitives.isWrapperType(class).

Class.isPrimitive () funciona para primitivas

Para aquellos a los que les gusta el código conciso.

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);
}

A partir de Java 1.5 en adelante, hay una nueva característica llamada auto-boxing. El compilador lo hace por sí mismo. Cuando ve una oportunidad, convierte un tipo primitivo en su clase contenedora apropiada.

Lo que probablemente está sucediendo aquí es cuando declaras

Object o = i;

El compilador compilará esta declaración diciendo

Object o = Integer.valueOf(i);

Esto es auto-boxeo. Esto explicaría la salida que está recibiendo. Esta página de la especificación Java 1.5 explica el auto-boxing con más detalle.

Integerno es un primitivo, Class.isPrimitive()no está mintiendo.

Creo que esto sucede debido al auto-boxing .

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

Puede implementar un método de utilidad que coincida con estas clases de boxeo específicas y le proporcione si una determinada clase es primitiva.

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);
}

Tienes que lidiar con el auto-boxing de java.
Tomemos el código

prueba de clase pública
{
    public static void main (String [] args)
    {
        int i = 3;
        Objeto o = i;
        regreso;
    }
}

Compilado a partir de "test.java"
prueba de clase pública extiende java.lang.Object {
prueba pública ();
  Código:
   0: aload_0
   1: invocarespecial # 1; // Método java / lang / Object. "" :() V
   4: regreso


public static void main (java.lang.String []);
  Código:
   0: iconst_3
   1: istore_1
   2: iload_1
   3: invocaestático # 2; // Método java / lang / Integer.valueOf: (I) Ljava / lang / Integer;
   6: astore_2
   7: regreso

}

invokestático # 2; // Método 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;
}

Solo para que pueda ver que es posible que isPrimitive devuelva verdadero (ya que tiene suficientes respuestas que le muestran por qué es falso):

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

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

Esto es importante en la reflexión cuando un método toma "int" en lugar de un "Integer".

Este código funciona:

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)
    {
    }
}

Este código falla (no puedo encontrar el método):

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)
    {
    }
}

Como ya han dicho varias personas, esto se debe al autoboxing .

Usted podría crear un método de utilidad para comprobar si la clase del objeto es Integer, Double, etc, pero no hay manera de saber si un objeto fue creado por autoboxing una primitiva ; una vez que está en caja, parece un objeto creado explícitamente.

Entonces, a menos que sepa con certeza que su matriz nunca contendrá una clase contenedora sin autoboxing, no hay una solución real.

Los tipos de envoltorios primitivos no responderán a este valor. Esto es para la representación de clases de primitivas, aunque aparte de la reflexión, no puedo pensar en demasiados usos para ello. Así por ejemplo

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

imprime "falso", pero

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;
}

imprime "verdadero"

Llego tarde al programa, pero si estás probando un campo, puedes usar 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));
    }
}

Los documentos de Oracle enumeran los 8 tipos primitivos.

Esta es la forma más sencilla que se me ocurre. Las clases contenedoras están presentes solo en java.langpackage. Y aparte de las clases contenedoras, ninguna otra clase java.langtiene un nombre de campo TYPE. Puede usar eso para verificar si una clase es una clase Wrapper o no.

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;        
}

Obtenga BeanUtils de Spring http://static.springsource.org/spring/docs/3.0.x/javadoc-api/

Probablemente la variación de Apache (beans comunes) tenga una funcionalidad similar.

podría determinar si un objeto es de tipo contenedor mediante las siguientes declaraciones:

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

y también puede determinar un objeto primitivo utilizando el método 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

Para los usuarios de javapoet , también existe esta forma:

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