Déterminer si un Objet est de type primitif

Question

J'ai un Object[] tableau, et je suis en train d'essayer de trouver ceux qui sont primitives. J'ai essayé d'utiliser Class.isPrimitive(), mais il semble que je suis en train de faire quelque chose de mal:

int i = 3;
Object o = i;

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

imprime java.lang.Integer, false.

Est-il une bonne façon ou d'une autre?

Answer 1

Les types en Object[] ne sera jamais vraiment être primitif - parce que vous avez des références! Ici le type d' i est int alors que le type de l'objet référencé par o est Integer (en raison de l'auto-boxing).

Cela sonne comme vous avez besoin de savoir si le type est "wrapper pour des primitifs". Je ne pense pas qu'il n'y a rien construit dans les bibliothèques standard pour cela, mais il est facile de code:

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

commons-lang ClassUtils a pertinentes méthodes. La nouvelle version a:

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

Les anciennes versions ont wrapperToPrimitive(clazz) méthode, qui sera de retour la primitive de la correspondance. De sorte que vous pouvez faire:

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

Answer 3

Google Goyave Primitives de la bibliothèque dispose d'un utilitaire qui vérifie si une classe est un wrapper pour un type primitif: http://guava-libraries.googlecode.com/svn/trunk/javadoc/com/google/common/primitives/Primitives.html

Primitives.isWrapperType(class)

Classe.isPrimitive() fonctionne pour les primitives

Answer 4

Pour ceux qui aiment laconique code.

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 5

Départ en Java 1.5, il est une nouvelle fonctionnalité appelée auto-boxing. Le compilateur fait lui-même. Quand il voit une occasion, il convertit un type primitif dans sa classe wrapper.

Ce qui est probablement ce qui se passe ici, c'est quand vous déclarez

Object o = i;

Le compilateur compile cette déclaration comme disant

Object o = Integer.valueOf(i);

C'est de l'auto-boxing. Cela expliquerait la sortie que vous recevez. Cette page, à partir de Java 1.5 spec explique l'auto-boxe plus dans le détail.