Cómo comprobar si un objeto es una matriz de un cierto tipo

Question

Tengo un objeto Field field.

Me gustaría comprobar si field es un objeto del tipo Foo o una matriz: Foo[].

pseudo código:

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

Es esto posible?

He intentado

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

Pero esto sólo me permitiría comprobar si field es una matriz.

Al hacer esto, por el contrario, sólo se comprobará si se trata de un objeto de Foo

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

alguna idea de cómo hacer esto?

Gracias.

Answer 1

Aquí hay un código utilicé una vez para manejar matrices de todos los tipos primitivos de Java. Como no extienden la clase Object, una instancia de verificación para Object [] es insuficiente.

/* 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[]) 

Eso debería hacerlo.

Answer 3

Dado que los tipos de matriz están materializadas, sólo puede utilizar

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

ejemplo completo:

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

Suponiendo que el campo que mencionas es un java.lang.reflect.Field, sólo puede hacer

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

Answer 5

Comparación simple debería funcionar

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

me gustaría hacer algo como esto:

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