Déterminer si un objet est de type primitif

J'ai un Object[]tableau et j'essaie de trouver ceux qui sont primitifs. J'ai essayé d'utiliser Class.isPrimitive(), mais il semble que je fais quelque chose de mal:

int i = 3;
Object o = i;

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

impressions java.lang.Integer, false.

Y a-t-il une bonne façon ou une alternative?

Les types dans un Object[]ne seront jamais vraiment primitifs - car vous avez des références! Ici, le type de iest intalors que le type de l'objet référencé par oest Integer(dû à l'auto-boxing).

Il semble que vous ayez besoin de savoir si le type est un "wrapper pour primitive". Je ne pense pas qu'il y ait quoi que ce soit intégré dans les bibliothèques standard pour cela, mais c'est facile à coder:

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 a des méthodes pertinentes .

La nouvelle version a:

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

Les anciennes versions ont la wrapperToPrimitive(clazz)méthode, qui retournera la correspondance primitive .

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

La bibliothèque goyave de Google dispose d' un utilitaire Primitives qui contrôle si une classe est un type d'emballage pour une primitive: Primitives.isWrapperType(class).

Class.isPrimitive () fonctionne pour les primitives

Pour ceux qui aiment le code laconique.

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

À partir de Java 1.5 et plus, il existe une nouvelle fonctionnalité appelée auto-boxing. Le compilateur le fait lui-même. Lorsqu'il voit une opportunité, il convertit un type primitif en sa classe wrapper appropriée.

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

Object o = i;

Le compilateur compilera cette déclaration comme disant

Object o = Integer.valueOf(i);

C'est de la boxe automatique. Cela expliquerait la sortie que vous recevez. Cette page de la spécification Java 1.5 explique plus en détail l'auto-boxing.

Integern'est pas un primitif, Class.isPrimitive()ne ment pas.

Je pense que cela est dû à la boxe automatique .

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

Vous pouvez implémenter une méthode utilitaire qui correspond à ces classes de boxe spécifiques et vous indique si une certaine classe est primitive.

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

Vous devez gérer l'auto-boxing de java.
Prenons le code

test de classe publique
{
    public static void main (String [] args)
    {
        int i = 3;
        Objet o = i;
        revenir;
    }
}

Compilé à partir de "test.java"
le test de classe publique étend java.lang.Object {
test public ();
  Code:
   0: aload_0
   1: invokespecial # 1; // Méthode java / lang / Object. "" :() V
   4: retour


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

}

invokestatic # 2; // Méthode 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;
}

Juste pour que vous puissiez voir qu'il est possible pour isPrimitive de retourner true (puisque vous avez suffisamment de réponses vous montrant pourquoi il est faux):

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

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

Ceci est important dans la réflexion lorsqu'une méthode prend "int" plutôt qu'un "Integer".

Ce code fonctionne:

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

Ce code échoue (impossible de trouver la méthode):

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

Comme plusieurs personnes l'ont déjà dit, cela est dû à l' auto-boxe .

Vous pouvez créer une méthode utilitaire pour vérifier si la classe de l'objet est Integer, Doubleetc. Mais il n'y a aucun moyen de savoir si un objet a été créé par autoboxing d'une primitive ; une fois qu'il est encadré, il ressemble à un objet créé explicitement.

Donc, à moins que vous ne sachiez avec certitude que votre tableau ne contiendra jamais de classe wrapper sans autoboxing, il n'y a pas de vraie solution.

Les types de wrapper primitve ne répondront pas à cette valeur. C'est pour la représentation de classe des primitives, bien que mis à part la réflexion, je ne peux pas penser à trop d'utilisations pour cela à la légère. Donc, par exemple

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

affiche «faux», mais

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

Je suis en retard au salon, mais si vous testez un champ, vous pouvez utiliser 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));
    }
}

Les documents Oracle répertorient les 8 types primitifs.

C'est le moyen le plus simple auquel je puisse penser. Les classes wrapper sont présentes uniquement dans java.langpackage. Et à part les classes wrapper, aucune autre classe dans java.langn'a de champ nommé TYPE. Vous pouvez l'utiliser pour vérifier si une classe est une classe Wrapper ou non.

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

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

La variante Apache (les beans communs) a probablement des fonctionnalités similaires.

vous pouvez déterminer si un objet est de type wrapper en suivant des instructions:

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

et vous pouvez également déterminer un objet primitif en utilisant la méthode 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

Pour les utilisateurs de javapoet , il existe également cette méthode:

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