Was ist der Unterschied zwischen instanceof und Class.isAssignableFrom (…)?

Welche der folgenden Möglichkeiten ist besser?

a instanceof B

oder

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

Der einzige Unterschied, den ich kenne, ist, wenn 'a' null ist, gibt der erste false zurück, während der zweite eine Ausnahme auslöst. Geben sie sonst immer das gleiche Ergebnis?

Bei der Verwendung instanceofmüssen Sie die Klasse von Bzur Kompilierungszeit kennen. Bei der Verwendung isAssignableFrom()kann es dynamisch sein und sich zur Laufzeit ändern.

instanceofkann nur mit Referenztypen verwendet werden, nicht mit primitiven Typen. isAssignableFrom()kann mit allen Klassenobjekten verwendet werden:

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

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

In Bezug auf die Leistung sprechen:

TL; DR

Verwenden Sie isInstance oder instanceof mit ähnlicher Leistung. isAssignableFrom ist etwas langsamer.

Sortiert nach Leistung:

1. isInstance
2. Instanz von (+ 0,5%)
3. isAssignableFrom (+ 2,7%)

Basierend auf einem Benchmark von 2000 Iterationen unter JAVA 8 Windows x64 mit 20 Aufwärmiterationen.

In der Theorie

Mit einem weichen Bytecode-Viewer können wir jeden Operator in Bytecode übersetzen.

Im Zusammenhang mit:

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

Wenn wir messen, wie viele Bytecode-Anweisungen von jedem Operator verwendet werden, können wir erwarten, dass instanceof und isInstance schneller sind als isAssignableFrom . Die tatsächliche Leistung wird jedoch NICHT durch den Bytecode bestimmt, sondern durch den Maschinencode (der plattformabhängig ist). Lassen Sie uns für jeden Operator einen Mikro-Benchmark durchführen.

Der Benchmark

Gutschrift: Wie von @ aleksandr-dubinsky empfohlen und danke an @yura für die Bereitstellung des Basiscodes, hier ein JMH- Benchmark (siehe diese Tuning-Anleitung ):

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

Hat die folgenden Ergebnisse geliefert (Punktzahl ist eine Anzahl von Operationen in einer Zeiteinheit . Je höher die Punktzahl, desto besser):

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

Warnung

• Der Benchmark ist JVM- und plattformabhängig. Da es zwischen den einzelnen Vorgängen keine signifikanten Unterschiede gibt, kann es sein, dass auf einer anderen JAVA-Version und / oder Plattformen wie Solaris, Mac oder Linux ein anderes Ergebnis (und möglicherweise eine andere Reihenfolge!) Erzielt wird.
• Der Benchmark vergleicht die Leistung von "Ist B eine Instanz von A", wenn "B A direkt erweitert". Wenn die Klassenhierarchie tiefer und komplexer ist (wie B X erweitert, das Y erweitert, das Z erweitert, das A erweitert), können die Ergebnisse unterschiedlich sein.
• Es wird normalerweise empfohlen, den Code zuerst zu schreiben, indem Sie einen der Operatoren auswählen (den bequemsten), und dann Ihren Code zu profilieren, um zu überprüfen, ob ein Leistungsengpass vorliegt. Vielleicht ist dieser Operator im Kontext Ihres Codes vernachlässigbar, oder vielleicht ...
• In Bezug auf den vorherigen Punkt kann instanceofder Kontext Ihres Codes möglicherweise einfacher optimiert werden als isInstancebeispielsweise ...

Nehmen Sie als Beispiel die folgende Schleife:

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;

Dank der JIT wird der Code irgendwann optimiert und wir erhalten:

• Instanz von: 6ms
• isInstance: 12ms
• isAssignableFrom: 15ms

Hinweis

Ursprünglich hat dieser Beitrag einen eigenen Benchmark mit einer for- Schleife in JAVA durchgeführt, was zu unzuverlässigen Ergebnissen führte, da einige Optimierungen wie Just In Time die Schleife beseitigen können. Daher wurde hauptsächlich gemessen, wie lange der JIT-Compiler für die Optimierung der Schleife benötigt hat: Weitere Informationen finden Sie unter Leistungstest unabhängig von der Anzahl der Iterationen

Verwandte Fragen

• Erzeugt die Instanz des Betreibers viel Overhead? Warum?
• Wie wird instanceof in JAVA implementiert?
• Die Auswirkungen der Verwendung von instanceof in Java auf die Leistung

Ein direkteres Äquivalent zu a instanceof Bist

B.class.isInstance(a)

Dies funktioniert (false zurück) , wenn aist nullauch.

Abgesehen von den oben erwähnten grundlegenden Unterschieden gibt es in der Klasse einen subtilen Kernunterschied zwischen der Instanz des Operators und der Methode isAssignableFrom.

Lesen Sie instanceofals "Ist dies (der linke Teil) die Instanz dieser oder einer Unterklasse davon (der rechte Teil)" und lesen Sie x.getClass().isAssignableFrom(Y.class)als "Kann ich schreiben X x = new Y()". Mit anderen Worten, die Instanz des Operators prüft, ob das linke Objekt dasselbe oder eine Unterklasse der rechten Klasse ist, während isAssignableFromprüft, ob wir der Referenz der Klasse, für die die Methode aufgerufen wird, ein Objekt der Parameterklasse (von) zuweisen können.
Beachten Sie, dass beide die tatsächliche Instanz und nicht den Referenztyp berücksichtigen.

Betrachten Sie ein Beispiel für 3 Klassen A, B und C, wobei C B und B A erweitert.

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.

Es gibt noch einen weiteren Unterschied:

Die Nullinstanz von X ist falseegal, was X ist

null.getClass (). isAssignableFrom (X) löst eine NullPointerException aus

Es gibt noch einen weiteren Unterschied. Wenn der Typ (Klasse), gegen den getestet werden soll, dynamisch ist, z. B. als Methodenparameter übergeben, wird die Instanz ihn nicht für Sie schneiden.

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

aber du kannst tun:

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

Hoppla, ich sehe, dass diese Antwort bereits behandelt wird. Vielleicht ist dieses Beispiel für jemanden hilfreich.

Dieser Thread gab mir einen Einblick in die instanceofUnterschiede isAssignableFrom, also dachte ich, ich würde etwas von mir teilen.

Ich habe festgestellt, dass die Verwendung isAssignableFromdie einzige (wahrscheinlich nicht die einzige, aber möglicherweise die einfachste) Möglichkeit ist, sich selbst zu fragen, ob eine Referenz einer Klasse Instanzen einer anderen annehmen kann, wenn man Instanzen keiner Klasse hat, um den Vergleich durchzuführen.

Daher fand ich es nicht gut, den instanceofOperator zum Vergleichen der Zuweisbarkeit zu verwenden, wenn ich nur Klassen hatte, es sei denn, ich wollte eine Instanz aus einer der Klassen erstellen. Ich dachte, das wäre schlampig.

instanceof kann auch nicht mit primitiven oder generischen Typen verwendet werden. Wie im folgenden Code:

//Define Class< T > type ... 

Object e = new Object();

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

Der Fehler lautet: Es kann keine Instanz der Prüfung für den Typparameter T durchgeführt werden. Verwenden Sie stattdessen das Löschobjekt, da zur Laufzeit weitere allgemeine Typinformationen gelöscht werden.

Kompiliert nicht, da beim Löschen des Typs die Laufzeitreferenz entfernt wird. Der folgende Code wird jedoch kompiliert:

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

Betrachten Sie die folgende Situation. Angenommen, Sie möchten überprüfen, ob Typ A eine Superklasse des Typs obj ist, dann können Sie auch gehen

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

ODER

... obj Instanz von A ...

Für die isAssignableFrom-Lösung muss jedoch der Typ des Objekts hier sichtbar sein. Wenn dies nicht der Fall ist (z. B. könnte der Typ von obj einer privaten inneren Klasse angehören), ist diese Option deaktiviert. Die Instanz der Lösung würde jedoch immer funktionieren.

isAssignableFrom(A, B) =

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

Der obige Pseudocode ist eine Definition von, wenn Referenzen des Typs / der Klasse A aus Referenzen des Typs / der Klasse B zuweisbar sind. Es handelt sich um eine rekursive Definition. Für einige mag es hilfreich sein, für andere mag es verwirrend sein. Ich füge es hinzu, falls jemand es nützlich finden sollte. Dies ist nur ein Versuch, mein Verständnis zu erfassen, es ist nicht die offizielle Definition. Es wird in einer bestimmten Java VM-Implementierung verwendet und funktioniert für viele Beispielprogramme. Daher kann ich nicht garantieren, dass es alle Aspekte von isAssignableFrom erfasst, aber es ist nicht vollständig deaktiviert.

Apropos Leistung "2" (mit 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();
}
}

Es gibt:

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

Damit wir schließen können: Instanz von so schnell wie isInstance () und isAssignableFrom () nicht weit entfernt (+ 0,9% Ausführungszeit). Also kein wirklicher Unterschied, was auch immer Sie wählen

Wie wäre es mit einigen Beispielen, um es in Aktion zu zeigen ...

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

Einige Tests, die wir in unserem Team durchgeführt haben, zeigen, dass dies A.class.isAssignableFrom(B.getClass())schneller funktioniert als B instanceof A. Dies kann sehr nützlich sein, wenn Sie dies bei einer großen Anzahl von Elementen überprüfen müssen.