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 版本是什么吗？