Java：使用 n 个变量或使用硬编码数组元素之间是否存在性能差异？

Question

我正在为自己制作一个程序，突然出现了这个问题。这个程序处理图形，所以我必须牢记性能。

如果我使用多个变量或使用带有硬编码索引的数组，性能是否会有所不同？如果有，哪个更好？

举例说明：

R = (X *  3.2406) + (Y * -1.5372) + (Z * -0.4986);
G = (X * -0.9689) + (Y *  1.8758) + (Z *  0.0415);
B = (X *  0.0557) + (Y * -0.2040) + (Z *  1.0570);

或

RGB[0] = (XYZ[0] *  3.2406) + (XYZ[1] * -1.5372) + (XYZ[2] * -0.4986);
RGB[1] = (XYZ[0] * -0.9689) + (XYZ[1] *  1.8758) + (XYZ[2] *  0.0415);
RGB[2] = (XYZ[0] *  0.0557) + (XYZ[1] * -0.2040) + (XYZ[2] *  1.0570);

提前致谢。

Answer 1

使用单独的变量很可能会更快。

为什么？ JVM 在运行时优化您的代码以使其更快。它跟踪每个变量的流程和值，以了解如何优化代码。例如，它可能会意识到方法的参数永远不会被分配，因此是常量。但它不会对数组的每个元素都这样做。数组只是被认为是一个巨大的可变变量。因此，当使用单独的变量时，您更有可能获得最佳代码。

Answer 2

肯定存在内存差异。

你的第一个场景使用（假设双打）：

8    8               8               8  = 24 bytes
R = (X *  3.2406) + (Y * -1.5372) + (Z * -0.4986);
8                                       = 32 bytes
G = (X * -0.9689) + (Y *  1.8758) + (Z *  0.0415);
8                                       = 40 bytes
B = (X *  0.0557) + (Y * -0.2040) + (Z *  1.0570);

第二种场景使用：

12 + 8    12 + 8               8                    8 = 56 bytes
RGB[0] = (XYZ[0] *  3.2406) + (XYZ[1] * -1.5372) + (XYZ[2] * -0.4986);
8                                                     = 64 bytes
RGB[1] = (XYZ[0] * -0.9689) + (XYZ[1] *  1.8758) + (XYZ[2] *  0.0415);
8                                                     = 72 bytes
RGB[2] = (XYZ[0] *  0.0557) + (XYZ[1] * -0.2040) + (XYZ[2] *  1.0570);

参考：http://www.javamex.com/tutorials/memory/object_memory_usage.shtml

Answer 3

你应该再想一想：

x,y,z 值从何而来？

你有一个 x[] 一个 y[] 和一个 z[] 坐标数组吗？ 你在哪里迭代？

for (int i = 0; i < len; i++) {
   process(x[i], y[i], z[i];
}

怀疑这在内部迭代会更快：

public void process(double x[], double y[], double z[]) {

   for (int i = 0; i < len; i++) {
       rbgb[0] = (x[i] * 3.24606 +  y[i] * 1.5372 + z[i] * -0.4986);

    }

}