在方法内部声明的数组与在方法外部声明并在内部用作输入的数组在时间上有所不同

Question

使用java尝试解决一个数学问题，并寻找提高解决效率的方法，我得到了非常显着的执行时间大幅增加，不知道它是怎么来的。经过几次测试，我可能已经找到了答案，但我仍然不知道这是如何发生的或为什么会发生。

这里是显示这个时间差的测试代码：

public class arrayAcessTime {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {

        AccessTime();
    }

    public static long getLargestPrimeFactor(long l, int[] x)
    {
        long p = 0, n = l/2, r = (long) Math.sqrt(l), y = 49;

        for(long i = 13; i <= r;)
        {
            for(int j = 0; j<x.length; j++)
            {
                if (l % i == 0) 
                {
                  n = l/i;
                } 

                else 
                {
                   n = l / (i + 1); 
                }

                i+=x[j];
            }
        }

        return p;
    }

    public static long getLargestPrimeFactor(long l)
    {
        long p = 0, n = l/2, r = (long) Math.sqrt(l), y = 49;

     int x[] = {2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, 2,         

      System.out.println("x size: " + x.length);

        for(long i = 13; i <= r;)
        {
            for(int j = 0; j<x.length; j++)
            {
                if (l % i == 0) 
                {
                  n = l/i;
                } 

                else 
                {
                   n = l / (i + 1); 
                }

                i+=x[j];
            }
        }

        return p;
    }

    public static void AccessTime() {

        int array2[] = {2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2,....} //too large to write here 


        long start;
        double diff;

        System.out.println("Array2 size: " + array2.length);

        start = System.currentTimeMillis();

        getLargestPrimeFactor(8798765600851475143L, array2);

        diff = (System.currentTimeMillis() - start) / 1000.0;

        System.out.println("Time: " + diff);


        start = System.currentTimeMillis();

        getLargestPrimeFactor(8798765600851475143L);

        diff = (System.currentTimeMillis() - start) / 1000.0;

        System.out.println("Time: " + diff);

    }
}

输出：

Array2 size: 5760
Time: 6.144
x size: 5760
Time: 30.225

如您所见，时间增加非常显着（大约 5 倍）。这两种方法几乎相同，只是一种在其中初始化了一个数组，而另一种将初始化的数组作为输入。这如何或为什么会导致时间显着增加？另一方面，对于相当小的数组（

Answer 1

我有一个预感 - 但这只是一种预感，而且仍然令人惊讶。

这是一个运行时间相对较长的方法 - 因此 Hotspot 可能会多次 JIT 编译它，应用越来越多的优化。

第一个方法的字节码很短，所以 JIT 很快。但是，您的第二种方法的字节码将是巨大的 - 这可能意味着大部分时间都花在 JITting 上。

您可以通过多次运行每个方法并打印出每次迭代需要多长时间来验证这一点 - 我预计每个方法的“后期”运行需要大约相同的时间。

再次，如果这能解释 所有 的差异，我会感到惊讶（我希望 JIT 优化初始化字节码一次，然后忽略它），但至少值得测试.