Bestimmen, ob ein Objekt vom primitiven Typ ist

Ich habe ein Object[]Array und versuche, diejenigen zu finden, die primitiv sind. Ich habe versucht zu verwenden Class.isPrimitive(), aber es scheint, dass ich etwas falsch mache:

int i = 3;
Object o = i;

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

druckt java.lang.Integer, false.

Gibt es einen richtigen Weg oder eine Alternative?

Die Typen in einem Object[]werden niemals wirklich primitiv sein - weil Sie Referenzen haben! Hier ist die Art der iist , intwährend die Art des Objekts referenziert durch oist Integer(aufgrund der Auto-Box).

Es hört sich so an, als müssten Sie herausfinden, ob der Typ ein "Wrapper für Primitive" ist. Ich glaube nicht, dass etwas in die Standardbibliotheken eingebaut ist, aber es ist einfach zu codieren:

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 hat relevante Methoden .

Die neue Version hat:

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

Die alten Versionen haben eine wrapperToPrimitive(clazz)Methode, die die primitive Entsprechung zurückgibt .

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

Die Guava-Bibliothek von Google verfügt über ein Dienstprogramm für Grundelemente , mit dem überprüft wird, ob eine Klasse ein Wrapper-Typ für ein Grundelement ist : Primitives.isWrapperType(class).

Class.isPrimitive () funktioniert für Grundelemente

Für diejenigen, die knappen Code mögen.

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

Ab Java 1.5 gibt es eine neue Funktion namens Auto-Boxing. Der Compiler macht das selbst. Wenn es eine Opportunity sieht, konvertiert es einen primitiven Typ in seine entsprechende Wrapper-Klasse.

Was hier wahrscheinlich passiert, ist, wenn Sie erklären

Object o = i;

Der Compiler kompiliert diese Anweisung wie folgt

Object o = Integer.valueOf(i);

Dies ist Auto-Boxing. Dies würde die Ausgabe erklären, die Sie erhalten. Diese Seite aus der Java 1.5-Spezifikation erklärt das Auto-Boxen ausführlicher.

Integerist kein Primitiv, Class.isPrimitive()lügt nicht.

Ich denke, das passiert durch Auto-Boxen .

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

Sie können eine Dienstprogrammmethode implementieren, die diesen bestimmten Boxklassen entspricht und Ihnen angibt, ob eine bestimmte Klasse primitiv ist.

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

Sie müssen sich mit dem Auto-Boxen von Java befassen.
Nehmen wir den Code

öffentlicher Klassentest
{
    public static void main (String [] args)
    {
        int i = 3;
        Objekt o = i;
        Rückkehr;
    }}
}}

Kompiliert aus "test.java"
öffentlicher Klassentest erweitert java.lang.Object {
öffentlicher Test ();
  Code:
   0: aload_0
   1: Aufrufspezial # 1; // Methode java / lang / Object. "" :() V.
   4: zurück


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

}}

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

Nur damit Sie sehen können, dass isPrimitive möglicherweise true zurückgibt (da Sie genügend Antworten haben, die Ihnen zeigen, warum es falsch ist):

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

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

Dies ist in der Reflexion wichtig, wenn eine Methode "int" anstelle einer "Ganzzahl" aufnimmt.

Dieser Code funktioniert:

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

Dieser Code schlägt fehl (die Methode kann nicht gefunden werden):

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

Wie bereits mehrere Leute gesagt haben, ist dies auf Autoboxing zurückzuführen .

Sie könnten eine Dienstprogramm Methode zu erstellen , ob die Klasse des Objekts zu überprüfen ist Integer, Doubleetc. Aber es gibt keine Möglichkeit zu wissen , ob ein Objekt von Autoboxing einen primitiven erstellt wurde ; Sobald es eingerahmt ist, sieht es aus wie ein explizit erstelltes Objekt.

Wenn Sie also nicht sicher sind, dass Ihr Array ohne Autoboxing niemals eine Wrapper-Klasse enthält, gibt es keine echte Lösung.

Die primitiven Wrapper-Typen reagieren nicht auf diesen Wert. Dies ist für die Klassendarstellung von Primitiven gedacht, obwohl ich mir, abgesehen von der Reflexion, nicht allzu viele Verwendungszwecke vorstellen kann. So zum Beispiel

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

druckt "false", aber

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

druckt "wahr"

Ich bin zu spät zur Show, aber wenn Sie ein Feld testen, können Sie Folgendes verwenden 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));
    }
}

In den Oracle-Dokumenten sind die 8 primitiven Typen aufgeführt.

Dies ist der einfachste Weg, den ich mir vorstellen kann. Die Wrapper-Klassen sind nur im java.langPaket vorhanden. Abgesehen von den Wrapper-Klassen hat keine andere Klasse in java.langein Feld mit dem Namen TYPE. Sie können damit überprüfen, ob eine Klasse eine Wrapper-Klasse ist oder nicht.

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

Holen Sie sich BeanUtils von Spring http://static.springsource.org/spring/docs/3.0.x/javadoc-api/

Wahrscheinlich hat die Apache-Variante (Commons Beans) eine ähnliche Funktionalität.

Sie können anhand der folgenden Anweisungen feststellen, ob ein Objekt vom Typ Wrapper ist:

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

Sie können auch ein primitives Objekt mithilfe der isPrimitive () -Methode bestimmen

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

Für Benutzer von Javapoet gibt es auch folgende Möglichkeiten:

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