Come controllare se un oggetto è un array di un certo tipo

Question

Ho un oggetto Field field.

Vorrei verificare se field è un oggetto di tipo o un array: Foo[].

codice Psuedo:

if field.getType() is Foo || field.getType is Foo[] 

è possibile?

Ho provato

if (field.getType().isArray()) 
    // do something 

ma questo sarebbe solo mi permette di controllare se field è un array.

In questo modo, al contrario, verificherà solo se si tratta di un oggetto di Foo

if (Foo.class.isAssignableFrom(field.getType()) 
    // do something 

Qualsiasi idea di come fare questo?

Grazie.

Answer 1

Ecco il codice che ho usato una volta per gestire array di tutti i tipi primitivi in ​​Java. Poiché non estendono la classe Object, un'istanza di controllo per Object [] non è sufficiente.

/* Check if the given object is an array. */ 
if (object.getClass().isArray()) { 

    Class<?> componentType; 
    componentType = object.getClass().getComponentType(); 

    if (componentType.isPrimitive()) { 

     if (boolean.class.isAssignableFrom(componentType)) { 
      for (boolean anElement : (boolean[]) object) { 
       /* ... */ 
      } 
     } 

     else if (byte.class.isAssignableFrom(componentType)) { 
      /* ... */ 
     } 

     else if (char.class.isAssignableFrom(componentType)) { 
      /* ... */ 
     } 

     else if (double.class.isAssignableFrom(componentType)) { 
      /* ... */ 
     } 

     else if (float.class.isAssignableFrom(componentType)) { 
      /* ... */ 
     } 

     else if (int.class.isAssignableFrom(componentType)) { 
      /* ... */ 
     } 

     else if (long.class.isAssignableFrom(componentType)) { 
      /* ... */ 
     } 

     else if (short.class.isAssignableFrom(componentType)) { 
      /* ... */ 
     } 

     /* No else. No other primitive types exist. */ 
    } 

    else { 
     /* Do something with Object[] here. */ 
    } 
} 

Answer 2

if (field instanceof Object[]) 

Che dovrebbe farlo.

Answer 3

Poiché i tipi di matrice sono reificati, si può semplicemente utilizzare

if (field.getType() == Foo.class || field.getType() == Foo[].class) { 
} 

esempio completa:

public class Scratchpad { 
    String[] strings; 

    public static void main(String[] args) throws NoSuchFieldException { 
     if (Scratchpad.class.getDeclaredField("strings").getType() == String[].class) { 
      System.out.println("They're Strings!"); 
     } 

     if (Scratchpad.class.getDeclaredField("strings").getType() == Long[].class) { 
      System.out.println("They're Longs!"); 
     } 
    } 
} 

Answer 4

Assumendo il campo si parla è un java.lang.reflect.Field, si può solo fare

field.getType().equals(Foo.class) || field.getType().equals(Foo[].class) 

Answer 5

semplice confrontare dovrebbe funzionare

import java.lang.reflect.Field; 

public class Main { 

String[] myStringArray; 
String[] myStringArray2; 

Object[] myObjectArray; 

String str; 


public static void main(String... args) { 
     Field[] flds = Main.class.getDeclaredFields(); 
     for (Field f : flds) { 
      Class<?> c = f.getType(); 

      if (c == String[].class) { 
       System.out.println("field" + f.getName() + " is String[]"); 
      } 
      if (c == String.class) { 
       System.out.println("field" + f.getName() + " is String"); 
      } 
      if (c == Object[].class) { 
       System.out.println("field" + f.getName() + " is Object[]"); 
      } 
     } 
} 

}

Answer 6

vorrei fare qualcosa di simile:

public static void main(String[] args) { 
    Foo foo = new Foo(); 
    Foo[] other = new Foo[1]; 
    other[0] = new Foo(); 

    System.out.println(isFooOrArrayOfFoo(foo)); 
    System.out.println(isFooOrArrayOfFoo(other[0])); 
    System.out.println(isFooOrArrayOfFoo(new Object())); 
} 

private static boolean isFooOrArrayOfFoo(Object o) { 
    return (o instanceof Foo || o.getClass().equals(Foo.class) && o.getClass().isArray()); 
}