Determinar se um objeto é do tipo primitivo

Eu tenho um Object[]array e estou tentando encontrar aqueles que são primitivos. Tentei usar Class.isPrimitive(), mas parece que estou fazendo algo errado:

int i = 3;
Object o = i;

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

impressões java.lang.Integer, false.

Existe um caminho certo ou alguma alternativa?

Os tipos em um Object[]nunca serão realmente primitivos - porque você tem referências! Aqui, o tipo de ié, intenquanto o tipo do objeto referenciado por oéInteger (devido ao auto-boxing).

Parece que você precisa descobrir se o tipo é um "invólucro para primitivo". Não acho que haja algo integrado nas bibliotecas padrão para isso, mas é 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 tem métodos relevantes .

A nova versão possui:

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

As versões antigas possuem wrapperToPrimitive(clazz)método, que retornará a correspondência primitiva .

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

A biblioteca Guava do Google tem um utilitário Primitives que verifica se uma classe é um tipo de wrapper para um primitivo:Primitives.isWrapperType(class) .

Class.isPrimitive () funciona para primitivos

Para quem gosta 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);
}

A partir do Java 1.5 e superior, há um novo recurso chamado caixa automática. O compilador faz isso sozinho. Quando ele vê uma oportunidade, ele converte um tipo primitivo em sua classe de invólucro apropriada.

O que provavelmente está acontecendo aqui é quando você declara

Object o = i;

O compilador irá compilar esta declaração dizendo

Object o = Integer.valueOf(i);

Isso é boxe automático. Isso explicaria a saída que você está recebendo. Esta página da especificação Java 1.5 explica a boxing automática com mais detalhes.

Integernão é um primitivo, Class.isPrimitive()não está mentindo.

Acho que isso acontece devido ao auto-boxing .

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

Você pode implementar um método utilitário que corresponda a essas classes específicas de boxe e forneça se uma determinada classe é 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);
}

Você tem que lidar com o auto-boxing de java.
Vamos pegar o código

teste de classe pública
{
    public static void main (String [] args)
    {
        int i = 3;
        Objeto o = i;
        Retorna;
    }
}

Compilado de "test.java"
teste de classe pública estende java.lang.Object {
teste público ();
  Código:
   0: aload_0
   1: invoca # 1 especial; // Método java / lang / Object. "" :() V
   4: retorno


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

}

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

Para que você possa ver que é possível que isPrimitive retorne verdadeiro (já que você tem respostas suficientes mostrando por que é falso):

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

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

Isso é importante na reflexão quando um método aceita "int" em vez de um "Inteiro".

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 falha (não é possível encontrar o 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 várias pessoas já disseram, isso se deve ao autoboxing .

Você poderia criar um método utilitário para verificar se a classe do objeto é Integer, Doubleetc. Mas não há como saber se um objeto foi criado por autoboxing de um primitivo ; depois de embalado, ele se parece com um objeto criado explicitamente.

Portanto, a menos que você tenha certeza de que seu array nunca conterá uma classe de wrapper sem autoboxing, não há solução real.

Os tipos de wrapper primitivos não responderão a este valor. Isso é para representação de classe de primitivos, embora, além da reflexão, eu não possa pensar em muitos usos para isso de improviso. Então, por exemplo

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

imprime "falso", mas

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 "verdadeiro"

Estou atrasado para o show, mas se você estiver testando um campo, pode 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));
    }
}

Os documentos do Oracle listam os 8 tipos primitivos.

Esta é a maneira mais simples que eu poderia imaginar. As classes de wrapper estão presentes apenas no java.langpacote. E além das classes de wrapper, nenhuma outra classe java.langpossui um campo nomeado TYPE. Você pode usar isso para verificar se uma classe é classe Wrapper ou não.

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

Obtenha o BeanUtils do Spring http://static.springsource.org/spring/docs/3.0.x/javadoc-api/

Provavelmente, a variação do Apache (beans comuns) tem funcionalidade semelhante.

você pode determinar se um objeto é do tipo wrapper por meio das instruções abaixo:

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

e você também pode determinar um objeto primitivo usando o 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 os usuários do javapoet , também existe esta maneira:

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