You're focusing on the wrong thing. The difference between instanceof and any other method for checking the same thing would probably not even be measurable. If performance is critical then Java is probably the wrong language. The major reason being that you can't control when the VM decides it wants to go collect garbage, which can take the CPU to 100% for several seconds in a large program (MagicDraw 10 was great for that). Unless you are in control of every computer this program will run on you can't guarantee which version of JVM it will be on, and many of the older ones had major speed issues. If it's a small app you may be ok with Java, but if you are constantly reading and discarding data then you will notice when the GC kicks in.

回答你的最后一个问题:除非分析人员告诉你，你在某个实例上花费了大量的时间:是的，你在吹毛求疵。

在考虑优化从来不需要优化的东西之前:以最易读的方式编写算法并运行它。运行它，直到jit编译器有机会优化它自己。如果这段代码有问题，可以使用分析器来告诉您，在哪里可以获得最大收益并进行优化。

在高度优化编译器的时代，您对瓶颈的猜测很可能是完全错误的。

在这个答案的真正精神(我完全相信):一旦jit编译器有机会优化它，我绝对不知道instanceof和==是如何关联的。

我忘了:永远不要测量第一次运行。

很难说一个特定的JVM是如何实现实例的，但在大多数情况下，对象与结构相当，类也是如此，每个对象结构都有一个指向它是实例的类结构的指针。实际上是instanceof for

if (o instanceof java.lang.String)

可能和下面的C代码一样快

if (objectStruct->iAmInstanceOf == &java_lang_String_class)

假设JIT编译器已经就位，并且工作出色。

考虑到这只是访问一个指针，在指针指向的某个偏移量处获得一个指针，并将其与另一个指针进行比较(这基本上与测试32位数字是否相等相同)，我认为操作实际上可以非常快。

但是，这并不一定是必须的，它在很大程度上取决于JVM。但是，如果这将成为代码中的瓶颈操作，我认为JVM实现相当糟糕。即使没有JIT编译器，只解释代码，也应该能够在几乎没有时间的情况下创建一个实例测试。

德米安和保罗提到了一个很好的观点;然而，要执行的代码的位置实际上取决于你想如何使用数据……

我非常喜欢可以以多种方式使用的小型数据对象。如果你采用覆盖(多态)方法，你的对象只能被“一种方式”使用。

这就是模式发挥作用的地方……

您可以使用双重分派(如在访问者模式中)要求每个对象传递自身“调用您”——这将解析对象的类型。但是(再次)，您需要一个可以对所有可能的子类型“做一些事情”的类。

我更喜欢使用策略模式，在这种模式下，您可以为想要处理的每个子类型注册策略。大致如下。注意，这只有助于精确的类型匹配，但它具有可扩展的优势——第三方贡献者可以添加自己的类型和处理程序。(这对于OSGi这样的动态框架很好，可以添加新的包)

希望这能激发一些其他的想法……

package com.javadude.sample;

import java.util.HashMap;
import java.util.Map;

public class StrategyExample {
    static class SomeCommonSuperType {}
    static class SubType1 extends SomeCommonSuperType {}
    static class SubType2 extends SomeCommonSuperType {}
    static class SubType3 extends SomeCommonSuperType {}

    static interface Handler<T extends SomeCommonSuperType> {
        Object handle(T object);
    }

    static class HandlerMap {
        private Map<Class<? extends SomeCommonSuperType>, Handler<? extends SomeCommonSuperType>> handlers_ =
            new HashMap<Class<? extends SomeCommonSuperType>, Handler<? extends SomeCommonSuperType>>();
        public <T extends SomeCommonSuperType> void add(Class<T> c, Handler<T> handler) {
            handlers_.put(c, handler);
        }
        @SuppressWarnings("unchecked")
        public <T extends SomeCommonSuperType> Object handle(T o) {
            return ((Handler<T>) handlers_.get(o.getClass())).handle(o);
        }
    }

    public static void main(String[] args) {
        HandlerMap handlerMap = new HandlerMap();

        handlerMap.add(SubType1.class, new Handler<SubType1>() {
            @Override public Object handle(SubType1 object) {
                System.out.println("Handling SubType1");
                return null;
            } });
        handlerMap.add(SubType2.class, new Handler<SubType2>() {
            @Override public Object handle(SubType2 object) {
                System.out.println("Handling SubType2");
                return null;
            } });
        handlerMap.add(SubType3.class, new Handler<SubType3>() {
            @Override public Object handle(SubType3 object) {
                System.out.println("Handling SubType3");
                return null;
            } });

        SubType1 subType1 = new SubType1();
        handlerMap.handle(subType1);
        SubType2 subType2 = new SubType2();
        handlerMap.handle(subType2);
        SubType3 subType3 = new SubType3();
        handlerMap.handle(subType3);
    }
}

You're focusing on the wrong thing. The difference between instanceof and any other method for checking the same thing would probably not even be measurable. If performance is critical then Java is probably the wrong language. The major reason being that you can't control when the VM decides it wants to go collect garbage, which can take the CPU to 100% for several seconds in a large program (MagicDraw 10 was great for that). Unless you are in control of every computer this program will run on you can't guarantee which version of JVM it will be on, and many of the older ones had major speed issues. If it's a small app you may be ok with Java, but if you are constantly reading and discarding data then you will notice when the GC kicks in.

现代JVM/JIT编译器已经消除了大多数传统的“慢”操作对性能的影响，包括instanceof、异常处理、反射等。

正如Donald Knuth所写的，“我们应该忘记小的效率，大约97%的时候:过早的优化是万恶之源。”instanceof的性能可能不是问题，所以在确定问题所在之前，不要浪费时间想出奇异的解决方案。