java - 速度分析器 - 基于参数类型的抽象方法或开关

Question

问题详细信息。我需要创建一个框架来执行各种检查，例如:- 日期 A 是否位于日期 B 和 C 之间？- 整数 A 是否大于整数 B 且小于整数 C？ETC。到目前为止，我正在考虑两种可能的实现，详细信息如下。

Impl1 - 根据检查类型使用单个类执行检查。

import java.sql.Time;
import java.util.Date;

public class SearchManager {

    public final static int SEARCH_TYPE_DATE = 0;
    public final static int SEARCH_TYPE_INT = 1;
    public final static int SEARCH_TYPE_STRING = 2;
    public final static int SEARCH_TYPE_TIME = 3;

    private final int searchType;

    public SearchManager(int searchType) {
        this.searchType = searchType;
    }

    public final boolean doCompare(Object minValue, Object maxValue, Object toBeCompared) {
        switch (this.searchType) {
            case SEARCH_TYPE_DATE: {
                return compareDates((Date) minValue, (Date) maxValue, (Date) toBeCompared);
            }
            case SEARCH_TYPE_INT: {
                return compareIntegers((Integer) minValue, (Integer) maxValue, (Integer) toBeCompared);
            }
            case SEARCH_TYPE_STRING: {
                return compareStrings(String.valueOf(minValue), String.valueOf(maxValue), String.valueOf(toBeCompared));
            }
            case SEARCH_TYPE_TIME: {
                return compareTimes((Time) minValue, (Time) maxValue, (Time) toBeCompared);
            }
            default:
                return false;
        }
    }

    private boolean compareDates(Date min, Date max, Date toBeCompared) {
        boolean result = false;
        // actual comparison
        return result;
    }

    private boolean compareIntegers(Integer min, Integer max, Integer toBeCompared) {
        boolean result = false;
        // actual comparison
        return result;
    }

    private boolean compareStrings(String min, String max, String toBeCompared) {
        boolean result = false;
        // actual comparison
        return result;
    }

    private boolean compareTimes(Time min, Time max, Time toBeComparedDate) {
        boolean result = false;
        // actual comparison
        return result;
    }
}

Impl2 - 使用抽象类或接口(interface)，并为每种搜索类型实现比较方法。

public abstract class AbstractSearch {

public final static int SEARCH_TYPE_DATE = 0;
public final static int SEARCH_TYPE_INT = 1;
public final static int SEARCH_TYPE_STRING = 2;
public final static int SEARCH_TYPE_TIME = 3;

public AbstractSearch() {
    super(); //just for fun
}

protected abstract boolean doCompare(Object minValue, Object maxValue, Object toBeComparedValue);

}

现在，在这个示例中，正如您可以想象的那样，对于 X 个不同的搜索类型，将创建 AbstractSearch 的 X 个实现。

想象一下，除了方法 doCompare(..) 之外，第二个实现中的类 AbstractSearch 还需要执行其他任务，这就是为什么需要一个接口(interface)不是我这个解决方案的第一个候选人，并且写了类似的东西

public abstract class AbstractSearch implements Searcheable

对我帮助不大，因为 AbstractSearch 或 SearchManager 将处理所有比较，并且，如果需要新的比较类型，则需要额外的类型/子类将为 Impl1 或 Impl2 中的相应父类(super class)声明实现。

我的问题是哪个实现速度更快？这非常重要，因为比较过程将在包含数千个元素的循环中调用。感谢您阅读/回答我的问题。

EDIT1:另外，请记住，对于第二个示例，minValue 和 maxValue 将从扩展 AbstractSearch 的类中提取，或者从扩展的类中提取SearchManager，与第一个示例相同。这些实现实际上是图形组件，允许用户输入最小值和最大值，然后，这些值将在循环中与表中显示的对象的某些 bean 属性进行比较。

EDIT2:我正在使用虚拟实现进行一些基准测试(我只想比较方法调用时间与切换执行时间)。结果令人惊讶:

• 使用 AbstractSearch(50 万次循环):-0.047 秒
• 使用 SearchManager(50 万次循环):-0.422 秒

有了这些结果，就可以安全地假设使用继承比使用 switch 快得多(甚至更糟糕的 if-else 测试)？

Answer 1

如果您想让此代码尽可能快，还可以尝试使用如下重载方法:

public final static boolean doCompare(Date min, Date max, Date toCompare) {
  // ...
}
public final static boolean doCompare(int min, int max, int toCompare) {
  // ...
}
// ...and so on

在编译时，编译器将根据您传递的类型生成对适当方法的直接调用。 (如果您传递的对象引用可能指向 4 种类型中任何一种的实例，则这将不起作用。)

如果您要比较的值是 int，则将它们传递给采用 Object 参数的方法将需要装箱和拆箱，这会增加开销。

如果性能确实很重要，我建议您使用静态方法，因为它们在许多 Java 实现中要快一些。

此外，您可以通过使用自己的内联代码进行比较来获得更多的性能，而不是使用 compareTo。

编辑:您在编辑后的问题中说 min 和 max 实际上将由 SearchManager< 的子类传入。在这种情况下，我将创建 SearchManager abstract，并将 doCompare 的不同实现放入 SearchManager 的每个子类中。我所说的关于静态方法在这种情况下不起作用。