Java多维数组：内存地址和遍历速度

Question

我了解在 Java 中处理二维数组时，您在循环中访问数组元素的顺序会影响遍历数组所需的时间：

int size = 500;
int[][] array = new int[size][size];

// Slower
for (int i = 0; i < size; i++) {
    for (int j = 0; j < size; j++) {
        array[j][i] = 1;
    }
}

// Faster
for (int i = 0; i < size; i++) {
    for (int j = 0; j < size; j++) {
        array[i][j] = 1;
    }
}

这对我来说很有意义，因为它需要更少的内存跳转，而是可以直接跳转到后续地址。

当对 3 维数组做同样的事情时，我对结果有点困惑：

Time:  12356332 nanoseconds. ([i][j][k])
Time:  18278948 nanoseconds. ([i][k][j])
Time:  13985288 nanoseconds. ([j][i][k])
Time: 126192723 nanoseconds. ([j][k][i])
Time:  39441820 nanoseconds. ([k][i][j])
Time: 156352618 nanoseconds. ([k][j][i])

[i][j][k] 和 [j][i][k] 的结果在大多数代码运行中是可互换的。这是为什么呢？

另外，您能否解释一下多维数组在 Java 中是如何存储的？

给定数组int[][][] array = new int[2][2][2]，内存地址是否会像这样（我的理解是每个块之间可能还有其他变量的附加数据，但我省略了这些情况，因为它们不相关 em>): （对不起，如果图像令人困惑，我只有油漆可以使用，并试图尽可能地表达布局。所以array[0][0][0] //[i][j][k] 将在地址06 中）

Answer 1

首先要考虑的是，仔细观察，java 没有多维数组，因为它是一个单一的实体。相反，java 只处理一维数组，但元素类型本身可以是数组类型，并且语言/编译器支持与例如相同的语法。 C 为多个维度提供快捷方式寻址一个元素。

例如int[][] twoDim = new int[50][100];实际上在内存中创建了51个对象； 一个 int[][] 类型的数组，其中有 50 个 int[] 类型的元素空间，然后用 int[100] 类型的数组填充这 50 个空间（剩下的 50 个对象）。这 51 个对象中的每一个都是独立的，它们可以位于堆中的任意位置。实际上它们甚至不需要在同一个语句中创建。

以下两种方法给出相同的数组作为结果，但第二种方法应该清楚真正发生了什么幕后：

 public int[][] createArrayA(int n, int m) {
     return new int[n][m];
 }

 public int[][] createArrayB(int n, int m) {
     int[][] array = new int[n][];
     for (int i=0; i<n; ++i)
         array[i] = new int[m];
     return array;
 }

请注意，在 createArrayB() 中，您也可以选择向后初始化 n 维（循环倒数而不是倒数），从而得到相同的数组：

 public int[][] createArrayC(int n, int m) {
     int[][] array = new int[n][];
     for (int i=n-1; i>=0; --i)
         array[i] = new int[m];
     return array;
 }

变体 B 和 C 的内存布局会不同，因为它们的分配顺序不同。但是不要假设它们的内存布局是一个常数，垃圾收集器稍后可能会将它们移动到堆中。

如果你关心访问速度，迭代数组的最快方法总是最左维度进入最外层循环， 最右边的维度进入最内层循环（这是严格围绕各个维度在内存中线性定位的事实而构建的）。并且 CPU 使用线性内存访问比使用随机访问更快（我不会在这里讨论为什么）。

在处理数组时可以考虑两个微优化。

首先是尺寸的顺序，当您可以随意订购尺寸时，将最小的放在最左边，最大的放在最右边：

int[][] slowArray = new int[10000][2];
int[][] fastArray = new int[2][10000];

第二个也节省了大量内存，因为慢速变体由 10000 x int[2] = 10001 个对象组成，而快速变体由 2 x int[10000] = 3 个对象组成。

第二个是使用数组维度的切片（它是代码不变移动的一种形式）：

long sum = 0;
int[][] fastArray = new int[2][10000];
for (int i=0; i<fastArray.length; ++i) {
    int[] subArray = fastArray[i];
    for (int j=0; j<subArray.length; ++j) {
        sum += subArray[j];
    }
}

定义一个局部变量 subArray 完全消除了内部循环的外部维度（毕竟，内部循环中 i 从不改变，所以为什么每次要解析 j 时都查找数组索引 i 呢？）。这种优化可能由即时编译器自动执行，但据我所知，它并非总是自动执行。偶尔的循环无关紧要，但如果数组遍历占用了您处理时间的很大一部分，则需要考虑进行优化。