¿Cuál es la diferencia entre instanceof y Class.isAssignableFrom (...)?

¿Cuál de los siguientes es mejor?

a instanceof B

o

B.class.isAssignableFrom(a.getClass())

La única diferencia que sé es que, cuando 'a' es nulo, el primero devuelve falso, mientras que el segundo arroja una excepción. Aparte de eso, ¿siempre dan el mismo resultado?

Cuando se utiliza instanceof, debe conocer la clase de Ben tiempo de compilación. Cuando se usa isAssignableFrom()puede ser dinámico y cambiar durante el tiempo de ejecución.

instanceofsolo se puede usar con tipos de referencia, no con tipos primitivos. isAssignableFrom()se puede usar con cualquier objeto de clase:

a instanceof int  // syntax error
3 instanceof Foo  // syntax error
int.class.isAssignableFrom(int.class)  // true

Ver http://java.sun.com/javase/6/docs/api/java/lang/Class.html#isAssignableFrom(java.lang.Class) .

Hablando en términos de rendimiento:

TL; DR

Utilice isInstance o instanceof que tienen un rendimiento similar. isAssignableFrom es un poco más lento.

Ordenado por rendimiento:

1. isInstance
2. instancia de (+ 0.5%)
3. isAssignableFrom (+ 2.7%)

Basado en un punto de referencia de 2000 iteraciones en JAVA 8 Windows x64, con 20 iteraciones de calentamiento.

En teoria

Usando un visor de código de bytes suave , podemos traducir cada operador en código de bytes.

En el contexto de:

package foo;

public class Benchmark
{
  public static final Object a = new A();
  public static final Object b = new B();

  ...

}

JAVA:

b instanceof A;

Bytecode:

getstatic foo/Benchmark.b:java.lang.Object
instanceof foo/A

JAVA:

A.class.isInstance(b);

Bytecode:

ldc Lfoo/A; (org.objectweb.asm.Type)
getstatic foo/Benchmark.b:java.lang.Object
invokevirtual java/lang/Class isInstance((Ljava/lang/Object;)Z);

JAVA:

A.class.isAssignableFrom(b.getClass());

Bytecode:

ldc Lfoo/A; (org.objectweb.asm.Type)
getstatic foo/Benchmark.b:java.lang.Object
invokevirtual java/lang/Object getClass(()Ljava/lang/Class;);
invokevirtual java/lang/Class isAssignableFrom((Ljava/lang/Class;)Z);

Al medir cuántas instrucciones de bytecode utiliza cada operador, podríamos esperar que instancia de e isInstance sea ​​más rápido que isAssignableFrom . Sin embargo, el rendimiento real NO está determinado por el código de bytes sino por el código de la máquina (que depende de la plataforma). Hagamos un micro benchmark para cada uno de los operadores.

El punto de referencia

Crédito: Según lo aconsejado por @ aleksandr-dubinsky, y gracias a @yura por proporcionar el código base, aquí hay un punto de referencia de JMH (consulte esta guía de ajuste ):

class A {}
class B extends A {}

public class Benchmark {

    public static final Object a = new A();
    public static final Object b = new B();

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MICROSECONDS)
    public boolean testInstanceOf()
    {
        return b instanceof A;
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MICROSECONDS)
    public boolean testIsInstance()
    {
        return A.class.isInstance(b);
    }

    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.MICROSECONDS)
    public boolean testIsAssignableFrom()
    {
        return A.class.isAssignableFrom(b.getClass());
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(TestPerf2.class.getSimpleName())
                .warmupIterations(20)
                .measurementIterations(2000)
                .forks(1)
                .build();

        new Runner(opt).run();
    }
}

Obtuve los siguientes resultados (el puntaje es una cantidad de operaciones en una unidad de tiempo , por lo tanto, cuanto mayor sea el puntaje, mejor):

Benchmark                       Mode   Cnt    Score   Error   Units
Benchmark.testIsInstance        thrpt  2000  373,061 ± 0,115  ops/us
Benchmark.testInstanceOf        thrpt  2000  371,047 ± 0,131  ops/us
Benchmark.testIsAssignableFrom  thrpt  2000  363,648 ± 0,289  ops/us

Advertencia

• El punto de referencia es JVM y depende de la plataforma. Dado que no hay diferencias significativas entre cada operación, es posible obtener un resultado diferente (¡y tal vez un orden diferente!) En una versión y / o plataformas JAVA diferentes como Solaris, Mac o Linux.
• el punto de referencia compara el rendimiento de "es B una instancia de A" cuando "B extiende A" directamente. Si la jerarquía de clases es más profunda y compleja (como B extiende X que extiende Y que extiende Z que extiende A), los resultados pueden ser diferentes.
• Por lo general, se recomienda escribir el código primero seleccionando uno de los operadores (el más conveniente) y luego perfilar su código para verificar si hay un cuello de botella en el rendimiento. Tal vez este operador sea insignificante en el contexto de su código, o tal vez ...
• en relación con el punto anterior, instanceofen el contexto de su código podría optimizarse más fácilmente que, isInstancepor ejemplo, ...

Para darle un ejemplo, tome el siguiente ciclo:

class A{}
class B extends A{}

A b = new B();

boolean execute(){
  return A.class.isAssignableFrom(b.getClass());
  // return A.class.isInstance(b);
  // return b instanceof A;
}

// Warmup the code
for (int i = 0; i < 100; ++i)
  execute();

// Time it
int count = 100000;
final long start = System.nanoTime();
for(int i=0; i<count; i++){
   execute();
}
final long elapsed = System.nanoTime() - start;

Gracias al JIT, el código se optimiza en algún momento y obtenemos:

• instancia de: 6 ms
• isInstance: 12ms
• isAssignableFrom: 15ms

Nota

Originalmente, esta publicación estaba haciendo su propio punto de referencia utilizando un bucle for en Java sin procesar, que dio resultados poco confiables ya que algunas optimizaciones como Just In Time pueden eliminar el bucle. Por lo tanto, medía principalmente cuánto tiempo tardó el compilador JIT en optimizar el ciclo: consulte Prueba de rendimiento independiente del número de iteraciones para obtener más detalles

Preguntas relacionadas

• ¿El operador instanceof genera mucha sobrecarga? ¿Por qué?
• ¿Cómo se implementa instanceof dentro de JAVA?
• El impacto en el rendimiento del uso de instanceof en Java

Un equivalente más directo a a instanceof Bes

B.class.isInstance(a)

Esto funciona (devuelve falso) cuando aes nulldemasiado.

Además de las diferencias básicas mencionadas anteriormente, existe una diferencia sutil central entre la instancia del operador y el método AsignableFrom en la clase.

Lea instanceofcomo “es esta (la parte izquierda) la instancia de esta o cualquier subclase de esto (la parte derecha)” y lea x.getClass().isAssignableFrom(Y.class)como “¿Puedo escribir?X x = new Y() ". En otras palabras, el operador instanceof verifica si el objeto izquierdo es el mismo o la subclase de la clase derecha, mientras que isAssignableFromverifica si podemos asignar el objeto de la clase de parámetro (from) a la referencia de la clase en la que se llama el método.
Tenga en cuenta que ambos consideran la instancia real, no el tipo de referencia.

Considere un ejemplo de 3 clases A, B y C donde C se extiende B y B se extiende A.

B b = new C();

System.out.println(b instanceof A); //is b (which is actually class C object) instance of A, yes. This will return true.  
System.out.println(b instanceof B); // is b (which is actually class C object) instance of B, yes. This will return true.  
System.out.println(b instanceof C); // is b (which is actually class C object) instance of C, yes. This will return true. If the first statement would be B b = new B(), this would have been false.
System.out.println(b.getClass().isAssignableFrom(A.class));//Can I write C c = new A(), no. So this is false.
System.out.println(b.getClass().isAssignableFrom(B.class)); //Can I write C c = new B(), no. So this is false.
System.out.println(b.getClass().isAssignableFrom(C.class)); //Can I write C c = new C(), Yes. So this is true.

También hay otra diferencia:

instancia nula de X es false no importa lo que sea X

null.getClass (). isAssignableFrom (X) arrojará una NullPointerException

Hay otra diferencia más. Si el tipo (Clase) para probar es dinámico, por ejemplo, se pasa como un parámetro de método, entonces instanceof no lo cortará por usted.

boolean test(Class clazz) {
   return (this instanceof clazz); // clazz cannot be resolved to a type.
}

pero puedes hacer:

boolean test(Class clazz) {
   return (clazz.isAssignableFrom(this.getClass())); // okidoki
}

Vaya, veo que esta respuesta ya está cubierta. Quizás este ejemplo sea útil para alguien.

Este hilo me dio una idea de cómo instanceofdifería isAssignableFrom, así que pensé en compartir algo propio.

He encontrado que usando isAssignableFrom es la única forma (probablemente no la única, pero posiblemente la más fácil) de preguntarse si una referencia de una clase puede tomar instancias de otra, cuando uno tiene instancias de ninguna clase para hacer la comparación.

Por lo tanto, no encontré que usar el instanceofoperador para comparar la asignabilidad fuera una buena idea cuando todo lo que tenía eran clases, a menos que contemplara crear una instancia de una de las clases; Pensé que esto sería descuidado.

instanceof tampoco se puede usar con tipos primitivos o genéricos. Como en el siguiente código:

//Define Class< T > type ... 

Object e = new Object();

if(e instanceof T) {
  // Do something.
}

El error es: No se puede realizar una instancia de comprobación con el parámetro de tipo T. Utilice en su lugar el objeto de borrado, ya que se borrará más información de tipo genérico en tiempo de ejecución.

No se compila debido a que la eliminación de tipo elimina la referencia de tiempo de ejecución. Sin embargo, el siguiente código compilará:

if( type.isAssignableFrom(e.getClass())){
  // Do something.
}

Considere la siguiente situación. Supongamos que desea verificar si el tipo A es una superclase del tipo de obj, puede ir

... A.class.isAssignableFrom (obj.getClass ()) ...

O

... obj instancia de A ...

Pero la solución isAssignableFrom requiere que el tipo de obj sea visible aquí. Si este no es el caso (p. Ej., El tipo de obj podría ser de una clase interna privada), esta opción está desactivada. Sin embargo, la instancia de solución siempre funcionaría.

isAssignableFrom(A, B) =

if (A == B) return true
else if (B == java.lang.Object) return false
else return isAssignableFrom(A, getSuperClass(B))

El pseudocódigo anterior es una definición de, si las referencias de tipo / clase A son asignables a partir de referencias de tipo / clase B. Es una definición recursiva. Para algunos puede ser útil, para otros puede ser confuso. Lo agrego en caso de que alguien lo encuentre útil. Esto es solo un intento de capturar mi comprensión, no es la definición oficial. Se utiliza en una determinada implementación de Java VM y funciona para muchos programas de ejemplo, por lo que, aunque no puedo garantizar que capture todos los aspectos de isAssignableFrom, no está completamente desactivado.

Hablando en términos de rendimiento "2" (con JMH):

class A{}
class B extends A{}

public class InstanceOfTest {

public static final Object a = new A();
public static final Object b = new B();

@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public boolean testInstanceOf()
{
    return b instanceof A;
}

@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public boolean testIsInstance()
{
    return A.class.isInstance(b);
}

@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public boolean testIsAssignableFrom()
{
    return A.class.isAssignableFrom(b.getClass());
}

public static void main(String[] args) throws RunnerException {
    Options opt = new OptionsBuilder()
            .include(InstanceOfTest.class.getSimpleName())
            .warmupIterations(5)
            .measurementIterations(5)
            .forks(1)
            .build();

    new Runner(opt).run();
}
}

Da:

Benchmark                            Mode  Cnt  Score   Error  Units
InstanceOfTest.testInstanceOf        avgt    5  1,972 ? 0,002  ns/op
InstanceOfTest.testIsAssignableFrom  avgt    5  1,991 ? 0,004  ns/op
InstanceOfTest.testIsInstance        avgt    5  1,972 ? 0,003  ns/op

Para que podamos concluir: instancia de tan rápido como isInstance () y isAssignableFrom () no muy lejos (+ 0.9% en tiempo de ejecución). Así que no hay diferencia real sea lo que sea que elijas

¿Qué tal algunos ejemplos para mostrarlo en acción ...

@Test
public void isInstanceOf() {
    Exception anEx1 = new Exception("ex");
    Exception anEx2 = new RuntimeException("ex");
    RuntimeException anEx3 = new RuntimeException("ex");

    //Base case, handles inheritance
    Assert.assertTrue(anEx1 instanceof Exception);
    Assert.assertTrue(anEx2 instanceof Exception);
    Assert.assertTrue(anEx3 instanceof Exception);

    //Other cases
    Assert.assertFalse(anEx1 instanceof RuntimeException);
    Assert.assertTrue(anEx2 instanceof RuntimeException);
    Assert.assertTrue(anEx3 instanceof RuntimeException);
}

@Test
public void isAssignableFrom() {
    Exception anEx1 = new Exception("ex");
    Exception anEx2 = new RuntimeException("ex");
    RuntimeException anEx3 = new RuntimeException("ex");

    //Correct usage = The base class goes first
    Assert.assertTrue(Exception.class.isAssignableFrom(anEx1.getClass()));
    Assert.assertTrue(Exception.class.isAssignableFrom(anEx2.getClass()));
    Assert.assertTrue(Exception.class.isAssignableFrom(anEx3.getClass()));

    //Incorrect usage = Method parameter is used in the wrong order
    Assert.assertTrue(anEx1.getClass().isAssignableFrom(Exception.class));
    Assert.assertFalse(anEx2.getClass().isAssignableFrom(Exception.class));
    Assert.assertFalse(anEx3.getClass().isAssignableFrom(Exception.class));
}

Algunas pruebas que hicimos en nuestro equipo muestran que A.class.isAssignableFrom(B.getClass())funciona más rápido que B instanceof A. Esto puede ser muy útil si necesita verificar esto en una gran cantidad de elementos.