What is the difference between instanceof and Class isAssignableFrom

Question

Which of the following is better   a instanceof B   or  B class isAssignableFrom a getClass      The only difference that I know of is  when  a  is null  the first returns false  while the second throws an exception  Other than that  do they always give the same result

User · Answer

There is also another difference   null instanceof X is false no matter what X is  null getClass   isAssignableFrom X  will throw a NullPointerException

User · Answer

There is also another difference   null instanceof X is false no matter what X is  null getClass   isAssignableFrom X  will throw a NullPointerException

User · Answer

instanceof cannot be used with primitive types or generic types either   As in the following code     Define Class lt  T  gt  type       Object e   new Object     if e instanceof T         Do something      The error is  Cannot perform instanceof check against type parameter T   Use it s erasure Object instead since further generic type information will be erased at runtime   Does not compile due to type erasure removing the runtime reference   However  the code below will compile   if  type isAssignableFrom e getClass           Do something

User · Answer

Consider following situation  Suppose you want to check whether type A is a super class of the type of obj  you can go either      A class isAssignableFrom obj getClass         OR      obj instanceof A      But the isAssignableFrom solution requires that the type of obj be visible here  If this is not the case  e g   the type of obj might be of a private inner class   this option is out  However  the instanceof solution would always work

User · Answer

instanceof cannot be used with primitive types or generic types either   As in the following code     Define Class lt  T  gt  type       Object e   new Object     if e instanceof T         Do something      The error is  Cannot perform instanceof check against type parameter T   Use it s erasure Object instead since further generic type information will be erased at runtime   Does not compile due to type erasure removing the runtime reference   However  the code below will compile   if  type isAssignableFrom e getClass           Do something

User · Answer

Apart from basic differences mentioned above  there is a core subtle difference between instanceof operator and isAssignableFrom method in Class   Read instanceof as    is this  the left part  the instance of this or any subclass of this  the right part     and read x getClass   isAssignableFrom Y class  as    Can I write X x   new Y       In other words  instanceof operator checks if the left object is same or subclass of right class  while isAssignableFrom checks if we can assign object of the parameter class  from  to the reference of the class on which the method is called  Note that both of these consider the actual instance not the reference type   Consider an example of 3 classes A  B and C where C extends B and B extends 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

User · Answer

There is yet another difference  If the type  Class  to test against is dynamic  e g  passed as a method parameter  then instanceof won t cut it for you   boolean test Class clazz       return  this instanceof clazz      clazz cannot be resolved to a type      but you can do   boolean test Class clazz       return  clazz isAssignableFrom this getClass         okidoki     Oops  I see this answer is already covered  Maybe this example is helpful to someone

User · Answer

Talking in terms of performance    TL DR  Use isInstance or instanceof which have similar performance  isAssignableFrom is slightly slower   Sorted by performance    isInstance instanceof    0 5   isAssignableFrom    2 7     Based on a benchmark of 2000 iterations on JAVA 8 Windows x64  with 20 warmup iterations   In theory  Using a soft like bytecode viewer we can translate each operator into bytecode   In the context of   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     Measuring how many bytecode instructions are used by each operator  we could expect instanceof and isInstance to be faster than isAssignableFrom  However  the actual performance is NOT determined by the bytecode but by the machine code  which is platform dependent   Let s do a micro benchmark for each of the operators   The benchmark  Credit  As advised by  aleksandr-dubinsky  and thanks to  yura for providing the base code  here is a JMH benchmark  see this tuning guide    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              Gave the following results  score is a number of operations in a time unit  so the higher the score the better    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   Warning   the benchmark is JVM and platform dependent  Since there are no significant differences between each operation  it might be possible to get a different result  and maybe different order   on a different JAVA version and or platforms like Solaris  Mac or Linux  the benchmark compares the performance of  is B an instance of A  when  B extends A  directly  If the class hierarchy is deeper and more complex  like B extends X which extends Y which extends Z which extends A   results might be different  it is usually advised to write the code first picking one of the operators  the most convenient  and then profile your code to check if there are a performance bottleneck  Maybe this operator is negligible in the context of your code  or maybe    in relation to the previous point  instanceof in the context of your code might get optimized more easily than an isInstance for example       To give you an example  take the following loop   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  lt  100    i    execute        Time it int count   100000  final long start   System nanoTime    for int i 0  i lt count  i        execute      final long elapsed   System nanoTime   - start    Thanks to the JIT  the code is optimized at some point and we get    instanceof  6ms  isInstance  12ms isAssignableFrom   15ms   Note  Originally this post was doing its own benchmark using a for loop in raw JAVA  which gave unreliable results as some optimization like Just In Time can eliminate the loop  So it was mostly measuring how long did the JIT compiler take to optimize the loop  see Performance test independent of the number of iterations for more details  Related questions   Does instanceof operator generate a lot of overhead   Why  How instanceof is implemented inside JAVA  The performance impact of using instanceof in Java

User · Answer

When using instanceof  you need to know the class of B at compile time   When using isAssignableFrom   it can be dynamic and change during runtime

User · Answer

When using instanceof  you need to know the class of B at compile time   When using isAssignableFrom   it can be dynamic and change during runtime

User · Answer

There is yet another difference  If the type  Class  to test against is dynamic  e g  passed as a method parameter  then instanceof won t cut it for you   boolean test Class clazz       return  this instanceof clazz      clazz cannot be resolved to a type      but you can do   boolean test Class clazz       return  clazz isAssignableFrom this getClass         okidoki     Oops  I see this answer is already covered  Maybe this example is helpful to someone

User · Answer

Consider following situation  Suppose you want to check whether type A is a super class of the type of obj  you can go either      A class isAssignableFrom obj getClass         OR      obj instanceof A      But the isAssignableFrom solution requires that the type of obj be visible here  If this is not the case  e g   the type of obj might be of a private inner class   this option is out  However  the instanceof solution would always work

User · Answer

isAssignableFrom A  B     if  A    B  return true else if  B    java lang Object  return false else return isAssignableFrom A  getSuperClass B     The pseudo code above is a definition of  if references of type class A is assignable from references of type class B  It is a recursive definition  To some it may be helpful  for others it may be confusing  I add it in case somebody should find it useful  This is just an attempt to capture my understanding  it is not the official definition  It is used in a certain Java VM implementation and works for many example programs  so while I cannot guarentee that it captures all aspects of isAssignableFrom  it is not completely off

User · Answer

instanceof can only be used with reference types  not primitive types   isAssignableFrom   can be used with any class objects   a instanceof int     syntax error 3 instanceof Foo     syntax error int class isAssignableFrom int class      true   See http   java sun com javase 6 docs api java lang Class html isAssignableFrom java lang Class

User · Answer

Talking in terms of performance  2   with 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          It gives   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   So that we can conclude  instanceof as fast as isInstance   and isAssignableFrom   not far away   0 9  executon time   So no real difference whatever you choose

User · Answer

isAssignableFrom A  B     if  A    B  return true else if  B    java lang Object  return false else return isAssignableFrom A  getSuperClass B     The pseudo code above is a definition of  if references of type class A is assignable from references of type class B  It is a recursive definition  To some it may be helpful  for others it may be confusing  I add it in case somebody should find it useful  This is just an attempt to capture my understanding  it is not the official definition  It is used in a certain Java VM implementation and works for many example programs  so while I cannot guarentee that it captures all aspects of isAssignableFrom  it is not completely off

User · Answer

Talking in terms of performance    TL DR  Use isInstance or instanceof which have similar performance  isAssignableFrom is slightly slower   Sorted by performance    isInstance instanceof    0 5   isAssignableFrom    2 7     Based on a benchmark of 2000 iterations on JAVA 8 Windows x64  with 20 warmup iterations   In theory  Using a soft like bytecode viewer we can translate each operator into bytecode   In the context of   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     Measuring how many bytecode instructions are used by each operator  we could expect instanceof and isInstance to be faster than isAssignableFrom  However  the actual performance is NOT determined by the bytecode but by the machine code  which is platform dependent   Let s do a micro benchmark for each of the operators   The benchmark  Credit  As advised by  aleksandr-dubinsky  and thanks to  yura for providing the base code  here is a JMH benchmark  see this tuning guide    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              Gave the following results  score is a number of operations in a time unit  so the higher the score the better    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   Warning   the benchmark is JVM and platform dependent  Since there are no significant differences between each operation  it might be possible to get a different result  and maybe different order   on a different JAVA version and or platforms like Solaris  Mac or Linux  the benchmark compares the performance of  is B an instance of A  when  B extends A  directly  If the class hierarchy is deeper and more complex  like B extends X which extends Y which extends Z which extends A   results might be different  it is usually advised to write the code first picking one of the operators  the most convenient  and then profile your code to check if there are a performance bottleneck  Maybe this operator is negligible in the context of your code  or maybe    in relation to the previous point  instanceof in the context of your code might get optimized more easily than an isInstance for example       To give you an example  take the following loop   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  lt  100    i    execute        Time it int count   100000  final long start   System nanoTime    for int i 0  i lt count  i        execute      final long elapsed   System nanoTime   - start    Thanks to the JIT  the code is optimized at some point and we get    instanceof  6ms  isInstance  12ms isAssignableFrom   15ms   Note  Originally this post was doing its own benchmark using a for loop in raw JAVA  which gave unreliable results as some optimization like Just In Time can eliminate the loop  So it was mostly measuring how long did the JIT compiler take to optimize the loop  see Performance test independent of the number of iterations for more details  Related questions   Does instanceof operator generate a lot of overhead   Why  How instanceof is implemented inside JAVA  The performance impact of using instanceof in Java

User · Answer

How about some examples to show it in action      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

User · Answer

This thread provided me some insight into how instanceof differed from isAssignableFrom  so I thought I d share something of my own   I have found that using isAssignableFrom to be the only  probably not the only  but possibly the easiest  way to ask one s self if a reference of one class can take instances of another  when one has instances of neither class to do the comparison   Hence  I didn t find using the instanceof operator to compare assignability to be a good idea when all I had were classes  unless I contemplated creating an instance from one of the classes  I thought this would be sloppy

User · Answer

A more direct equivalent to a instanceof B is  B class isInstance a    This works  returns false  when a is null too

User · Answer

Talking in terms of performance  2   with 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          It gives   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   So that we can conclude  instanceof as fast as isInstance   and isAssignableFrom   not far away   0 9  executon time   So no real difference whatever you choose

User · Answer

How about some examples to show it in action      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

User · Answer

When using instanceof  you need to know the class of B at compile time   When using isAssignableFrom   it can be dynamic and change during runtime

User · Answer

Apart from basic differences mentioned above  there is a core subtle difference between instanceof operator and isAssignableFrom method in Class   Read instanceof as    is this  the left part  the instance of this or any subclass of this  the right part     and read x getClass   isAssignableFrom Y class  as    Can I write X x   new Y       In other words  instanceof operator checks if the left object is same or subclass of right class  while isAssignableFrom checks if we can assign object of the parameter class  from  to the reference of the class on which the method is called  Note that both of these consider the actual instance not the reference type   Consider an example of 3 classes A  B and C where C extends B and B extends 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

User · Answer

A more direct equivalent to a instanceof B is  B class isInstance a    This works  returns false  when a is null too

User · Answer

some tests we did in our team show that A class isAssignableFrom B getClass    works faster than B instanceof A  this can be very useful if you need to check this on large number of elements

User · Answer

instanceof can only be used with reference types  not primitive types   isAssignableFrom   can be used with any class objects   a instanceof int     syntax error 3 instanceof Foo     syntax error int class isAssignableFrom int class      true   See http   java sun com javase 6 docs api java lang Class html isAssignableFrom java lang Class

User · Answer

instanceof can only be used with reference types  not primitive types   isAssignableFrom   can be used with any class objects   a instanceof int     syntax error 3 instanceof Foo     syntax error int class isAssignableFrom int class      true   See http   java sun com javase 6 docs api java lang Class html isAssignableFrom java lang Class

User · Answer

When using instanceof  you need to know the class of B at compile time   When using isAssignableFrom   it can be dynamic and change during runtime

User · Answer

This thread provided me some insight into how instanceof differed from isAssignableFrom  so I thought I d share something of my own   I have found that using isAssignableFrom to be the only  probably not the only  but possibly the easiest  way to ask one s self if a reference of one class can take instances of another  when one has instances of neither class to do the comparison   Hence  I didn t find using the instanceof operator to compare assignability to be a good idea when all I had were classes  unless I contemplated creating an instance from one of the classes  I thought this would be sloppy

User · Answer

some tests we did in our team show that A class isAssignableFrom B getClass    works faster than B instanceof A  this can be very useful if you need to check this on large number of elements

User · Answer

instanceof can only be used with reference types  not primitive types   isAssignableFrom   can be used with any class objects   a instanceof int     syntax error 3 instanceof Foo     syntax error int class isAssignableFrom int class      true   See http   java sun com javase 6 docs api java lang Class html isAssignableFrom java lang Class

[java] What is the difference between instanceof and Class.isAssignableFrom(...)?

Examples related to java

Examples related to instanceof

Examples related to reflection