Java:为什么我的对象数组的创建及其引用传递得如此缓慢？

Question

我试图弄清楚我在代码中创建对象数组的方式是否有问题，或者在 Java 中处理对象数组是否比我最初想象的更昂贵。

我有一个名为 ElementaryTransitionTerm 的简单枚举类，仅由两个原始成员变量组成。另一个类中的方法创建一个由该 Enum 常量组合组成的数组(数组的可能长度永远不会超过 3)。

问题是，程序在上述方法中总共花费(平均)13ms，尽管它只调用了 8 次。我不知道为什么。

运行时间有两种计算方式:

1. 通过 System.nanoTime() 调用包围对该方法的调用。

2. 将方法内的每个数组创建语句包围起来 System.nanoTime() 调用并对它们进行总结

这是ElementaryTransitionTerm枚举类:

public enum ElementaryTransitionTerm 
{
    MATCH(1, 0), INSERTION(0, 1), SUBSTITUTION(1, 1), DELETION(0, 0), FAILURE(0, 0);

    private final int I_OFFSET;
    private final int E_OFFSET;


    private ElementaryTransitionTerm(int iOffset, int eOffset)
    {
        I_OFFSET = iOffset;
        E_OFFSET = eOffset;

    }
}

这是有问题的方法，createTransitionTerms(以及用作参数的枚举类型的声明):

//'E' and 'I' are both private int fields in the parent class.

private enum RelevantSubwordHitIndexType { FIRST_INDEX, TRAILING_INDEX, NO_INDEX };

/**
 * Creates an array of ElementaryTransitionTerm constants.

 * @param hitIndexType     a RelevantSubwordHitIndexType enum constant
 */
private ElementaryTransitionTerm[] createTransitionTerms(RelevantSubwordHitIndexType hitIndexType)
{
    //Simple getter method chained in to String.length() call
    int onePastFinalBoundary = parentAutomaton.getAutomatonString().length(); 

    if(E < parentAutomaton.getMaxEditDistance())   //Simple getter method retrieving an int
    {
        if(I < onePastFinalBoundary - 1)           
        {
            switch(hitIndexType)
            {
                case FIRST_INDEX:       return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.MATCH};
                case TRAILING_INDEX:    return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.INSERTION, ElementaryTransitionTerm.SUBSTITUTION, ElementaryTransitionTerm.DELETION};
                default:                return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.INSERTION, ElementaryTransitionTerm.SUBSTITUTION};
            }
        }
        else if(I == onePastFinalBoundary - 1)     
        {
            switch(hitIndexType)
            {
                case FIRST_INDEX:       return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.MATCH};
                default:                return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.INSERTION, ElementaryTransitionTerm.SUBSTITUTION};
            }
        }
        else                            return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.INSERTION};     
    else                                            
    {
        if(I < onePastFinalBoundary)                
        {
            switch(hitIndexType)
            {
                case FIRST_INDEX:       return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.MATCH};
                default:                return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.FAILURE};
            }
        }
        else                            return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.FAILURE};
    }
}

该方法本质上是评估一小组条件，以创建一个小数组。然而，该方法运行 8 次的总执行时间并没有反射(reflect)出这一点。

我什至在 ElementaryTransitionTerm 中将要返回的数组声明为 public final 数组，并用对这些数组的引用替换上述方法中的创建语句，但是它对代码的运行时间完全没有影响。

我编写的代码可以在更短的时间内完成更多的工作。所以我很好奇为什么这个方法会这样。有人有什么想法吗？

编辑:

经过进一步测试，我发现了两件事:

1. 单独测试该方法会产生预期的结果(即 亚毫秒)结果。
2. 测试程序内的方法，似乎无论哪个 数组创建语句在第一次调用时执行 函数本质上负责我所看到的时间。全部 后续调用将在亚毫秒内完成。

关于#2:这是什么原因，我该如何纠正它？

Answer 1

运行你的代码，对该方法的一百万次调用需要 25-30 毫秒的时间。在 Sony Vaio Z、i5、4 GB RAM、Win 7 64、JDK 6 64 位上运行。

这是我尝试过的实际代码:

    private ElementaryTransitionTerm[] createTransitionTerms(RelevantSubwordHitIndexType hitIndexType) {
            //Simple getter method chained in to String.length() call
            int onePastFinalBoundary = "A".length(); 

//Here I also tried if(1 < 2) to change the if/else execution path, same run time for each.
            if(3 < 2)    {
                if(1 < 2) {
                    switch(hitIndexType) {
                        case FIRST_INDEX:       return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.MATCH};
                        case TRAILING_INDEX:    return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.INSERTION, ElementaryTransitionTerm.SUBSTITUTION, ElementaryTransitionTerm.DELETION};
                        default:                return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.INSERTION, ElementaryTransitionTerm.SUBSTITUTION};
                    }
                } else if(1 == 1) {
                    switch(hitIndexType) {
                        case FIRST_INDEX:       return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.MATCH};
                        default:                return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.INSERTION, ElementaryTransitionTerm.SUBSTITUTION};
                    }
                }
                else {                     
                    return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.INSERTION};
                }
            } else  {
                if(1 < 2) {
                    switch(hitIndexType) {
                        case FIRST_INDEX:       return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.MATCH};
                        default:                return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.FAILURE};
                    }
                } else {
                    return new ElementaryTransitionTerm[] {ElementaryTransitionTerm.FAILURE};
                }
            }
        }

        public static void main(String args[]) {
            T1 t = new T1();
            long st = System.currentTimeMillis();
            for(int i = 0 ; i<1000000; i++) {
                t.createTransitionTerms(RelevantSubwordHitIndexType.FIRST_INDEX);
            }
            long et = System.currentTimeMillis();
            System.out.println(et-st);
        }

您能告诉我们您测试的硬件、操作系统、JDK 版本是什么吗？