Qual é a diferença entre instanceof e Class.isAssignableFrom (…)?

Qual das alternativas a seguir é melhor?

a instanceof B

ou

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

A única diferença que eu sei é que, quando 'a' é nulo, o primeiro retorna falso, enquanto o segundo gera uma exceção. Fora isso, eles sempre dão o mesmo resultado?

Ao usar instanceof, você precisa conhecer a classe Bem tempo de compilação. Ao usá- isAssignableFrom()lo, pode ser dinâmico e mudar durante o tempo de execução.

instanceofsó pode ser usado com tipos de referência, não tipos primitivos. isAssignableFrom()pode ser usado com qualquer objeto de classe:

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

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

Falando em termos de desempenho:

TL; DR

Use Instância ou instância com desempenho semelhante. isAssignableFrom é um pouco mais lento.

Ordenado por desempenho:

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

Com base em uma referência de 2000 iterações no JAVA 8 Windows x64, com 20 iterações de aquecimento.

Em teoria

Usando um visualizador de código de byte suave , podemos converter cada operador em bytecode.

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

Medindo quantas instruções de código de byte são usadas por cada operador, podemos esperar que instanceof e isInstance sejam mais rápidos que isAssignableFrom . No entanto, o desempenho real NÃO é determinado pelo bytecode, mas pelo código da máquina (que depende da plataforma). Vamos fazer um micro benchmark para cada um dos operadores.

A referência

Crédito: Conforme recomendado por @ aleksandr-dubinsky, e obrigado a @yura por fornecer o código base, aqui está uma referência da JMH (consulte este guia 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();
    }
}

Forneceu os seguintes resultados (a pontuação é um número de operações em uma unidade de tempo ; portanto, quanto maior a pontuação, melhor):

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

Atenção

• o benchmark depende da JVM e da plataforma. Como não há diferenças significativas entre cada operação, pode ser possível obter um resultado diferente (e talvez uma ordem diferente!) Em uma versão JAVA diferente e / ou plataformas como Solaris, Mac ou Linux.
• o benchmark compara o desempenho de "é B uma instância de A" quando "B estende A" diretamente. Se a hierarquia de classes for mais profunda e complexa (como B estende X, que estende Y, que estende Z, que estende A), os resultados podem ser diferentes.
• geralmente é recomendável escrever o código primeiro escolhendo um dos operadores (o mais conveniente) e depois criar um perfil do código para verificar se há um gargalo de desempenho. Talvez esse operador seja insignificante no contexto do seu código ou talvez ...
• em relação ao ponto anterior, instanceofno contexto do seu código pode ser otimizado mais facilmente do que um isInstancepor exemplo ...

Para dar um exemplo, faça o seguinte 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 < 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;

Graças ao JIT, o código é otimizado em algum momento e obtemos:

• instanceof: 6ms
• isInstance: 12ms
• isAssignableFrom: 15ms

Nota

Originalmente, este post estava fazendo seu próprio benchmark usando um loop for em JAVA bruto, o que forneceu resultados não confiáveis, pois algumas otimizações como Just In Time podem eliminar o loop. Portanto, ele media principalmente quanto tempo o compilador JIT levou para otimizar o loop: consulte Teste de desempenho independente do número de iterações para obter mais detalhes

Perguntas relacionadas

• O operador instanceof gera muita sobrecarga? Por quê?
• Como instanceof é implementado dentro do JAVA?
• O impacto no desempenho do uso de instanceof em Java

Um equivalente mais direto a a instanceof Bé

B.class.isInstance(a)

Isso funciona (retorna falso) quando aestá nulltambém.

Além das diferenças básicas mencionadas acima, há uma diferença sutil principal entre instanceof operator e o métodoAssignableFrom em Class.

Leia instanceofcomo "esta (a parte esquerda) é a instância desta ou de qualquer subclasse desta (a parte direita)" e leia x.getClass().isAssignableFrom(Y.class)como "Posso escrever X x = new Y()". Em outras palavras, instanceof operator verifica se o objeto esquerdo é o mesmo ou subclasse da classe direita, enquanto isAssignableFromverifica se podemos atribuir objeto da classe de parâmetro (from) à referência da classe na qual o método é chamado.
Observe que ambos consideram a instância real e não o tipo de referência.

Considere um exemplo de 3 classes A, B e C em que C estende B e B estende 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.

Há também outra diferença:

instância nula de X falsenão importa o que seja X

null.getClass (). isAssignableFrom (X) lançará uma NullPointerException

Há ainda outra diferença. Se o tipo (Classe) a ser testado for dinâmico, por exemplo, passado como um parâmetro do método, instanceof não o cortará para você.

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

mas você pode fazer:

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

Ops, vejo que esta resposta já está coberta. Talvez este exemplo seja útil para alguém.

Esse tópico me deu uma ideia de como era instanceofdiferente isAssignableFrom, então pensei em compartilhar algo de minha autoria.

Eu descobri que usando isAssignableFrom a única (provavelmente não a única, mas possivelmente a mais fácil) maneira de perguntar a si mesmo se uma referência de uma classe pode ter instâncias de outra, quando alguém tem instâncias de nenhuma das classes para fazer a comparação.

Portanto, não achei que usar o instanceofoperador para comparar atribuibilidade fosse uma boa idéia quando tudo o que eu tinha eram classes, a menos que eu pensasse em criar uma instância a partir de uma das classes; Eu pensei que isso seria desleixado.

instanceof também não pode ser usado com tipos primitivos ou genéricos. Como no código a seguir:

//Define Class< T > type ... 

Object e = new Object();

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

O erro é: Não é possível executar a verificação da instância no parâmetro T. Use o objeto apagado, pois outras informações genéricas do tipo serão apagadas no tempo de execução.

Não é compilado devido ao apagamento do tipo, removendo a referência de tempo de execução. No entanto, o código abaixo será compilado:

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

Considere a seguinte situação. Suponha que você queira verificar se o tipo A é uma superclasse do tipo de obj, você pode ir

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

OU

... obj instance de A ...

Mas a solução isAssignableFrom exige que o tipo de obj seja visível aqui. Se esse não for o caso (por exemplo, o tipo de obj pode ser de uma classe interna privada), essa opção está desativada. No entanto, a instância da solução sempre funcionaria.

isAssignableFrom(A, B) =

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

O pseudo-código acima é uma definição de, se referências do tipo / classe A são atribuíveis a partir de referências do tipo / classe B. É uma definição recursiva. Para alguns, pode ser útil, para outros, pode ser confuso. Eu o adiciono no caso de alguém achar útil. Esta é apenas uma tentativa de capturar meu entendimento, não é a definição oficial. Ele é usado em uma certa implementação de Java VM e funciona para muitos programas de exemplo, portanto, embora eu não possa garantir que ele capture todos os aspectos de isAssignableFrom, não está completamente desativado.

Falando em termos de desempenho "2" (com 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();
}
}

Dá:

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 possamos concluir: instanceof tão rápido quanto isInstance () e isAssignableFrom () não muito longe (+ 0,9% do tempo de execução). Portanto, não há diferença real, o que você escolher

Que tal alguns exemplos para mostrá-lo em ação ...

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

alguns testes que fizemos em nossa equipe mostram que A.class.isAssignableFrom(B.getClass())funciona mais rápido que B instanceof A. isso pode ser muito útil se você precisar verificar isso em um grande número de elementos.