Determinando si un Objeto es del tipo primitivo

Question

Tengo una matriz Object[], y estoy tratando de encontrar las que son primitivas. He tratado de utilizar 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.

¿Hay una manera correcta o una alternativa?

Answer 1

Los tipos en un Object[] nunca realmente ser primitivo - ¡porque usted tiene referencias! Aquí el tipo de i es int, mientras que el tipo del objeto al que hace referencia o es Integer (debido al auto-boxing).

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

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

Answer 2

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

Answer 3

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

Probablemente lo que ocurre aquí es cuando se declara

Object o = i; 

El compilador compilará esta declaración diciendo

Object o = Integer.valueOf(i); 

Esto es auto-boxing. Esto explicaría el resultado que está recibiendo. This page from the Java 1.5 spec explains auto-boxing more in detail.

Answer 4

Creo que esto sucede debido a 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 proporciona si una cierta 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); 
} 

Answer 5

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

public class test 
{ 
    public static void main(String [ ] args) 
    { 
     int i = 3; 
     Object o = i; 
     return; 
    } 
}

Obtendrá la clase test.class y javap -c test le permitiremos inspeccionar el bytecode generado.

Compiled from "test.java" 
public class test extends java.lang.Object{ 
public test(); 
    Code: 
    0: aload_0 
    1: invokespecial #1; //Method java/lang/Object."":()V 
    4: return
 

public static void main(java.lang.String[]); 
    Code: 
    0: iconst_3 
    1: istore_1 
    2: iload_1 
    3: invokestatic #2; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer; 
    6: astore_2 
    7: return
 

}

Como se puede ver el compilador Java añade

invokestatic #2; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

para crear un nuevo número entero de su int y la almacena ese nuevo objeto en O a través de astore_2

Answer 6

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

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

De modo que a menos que esté seguro de que su matriz nunca contendrá una clase contenedora sin autoboxing, no hay una solución real.

Answer 7

Sólo así se puede ver que es es posible que isPrimitive para volver verdadero (ya que usted tiene suficientes respuestas que 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 importa en la reflexión cuando un método toma en "int "en lugar de un" Entero ".

Este código funciona: no

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 (no puede 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) 
    { 
    } 
} 

Answer 8

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

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

impresiones "falsos", 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; 
} 

impresiones "verdaderos"

Answer 9

Para aquellos que gustan de 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); 
} 

Answer 10

ponerme en contacto con BeanUtils de primavera http://static.springsource.org/spring/docs/3.0.x/javadoc-api/

Probablemente la variación de Apache (Commons frijoles) tiene una funcionalidad similar.

Answer 11

commons-langClassUtils 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 primitiva correspondencia. Por lo que puede hacer:

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

Answer 12

biblioteca de guayaba de Google tiene una utilidad primitivas que comprobar si una clase es un tipo de contenedor para una primitiva: http://guava-libraries.googlecode.com/svn/trunk/javadoc/com/google/common/primitives/Primitives.html

Primitives.isWrapperType(class) 

Class.isPrimitive() funciona para primitivas

Answer 13

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 

Answer 14

Esta es la manera más simple que se me ocurre. Las clases contenedoras están presentes solo en el paquete java.lang. Y aparte de las clases contenedoras, ninguna otra clase en java.lang tiene un campo llamado TYPE. Puede usar eso para verificar si una clase es 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;   
} 

Answer 15

estoy tarde para el espectáculo, pero si se está probando un campo, puede utilizar 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)); 
    } 
} 

La lista Oracle docs los 8 tipos primitivos.

Answer 16

que podrían determinar si un objeto es Wrapper por debajo de declaraciones:

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

y también se puede determinar un objeto primitivo utilizando el método isPrimitive()

Answer 17

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