多维数组

二维数组

二维数组就是数组的数组。定义一个二维数组如下：

多维数组 - 图1

因为ns包含3个数组，因此，ns.length为3。实际上ns在内存中的结构如下：

  1.                     ┌───┬───┬───┬───┐
  2.          ┌───┐  ┌──▶│ 1 │ 2 │ 3 │ 4 │
  3. ns ─────▶│░░░│──┘   └───┴───┴───┴───┘
  4.          ├───┤      ┌───┬───┬───┬───┐
  5.          │░░░│─────▶│ 5 │ 6 │ 7 │ 8 │
  6.          ├───┤      └───┴───┴───┴───┘
  7.          │░░░│──┐   ┌───┬───┬───┬───┐
  8.          └───┘  └──▶│ 9 │10 │11 │12 │
  9.                     └───┴───┴───┴───┘

如果我们定义一个普通数组arr0，然后把ns[0]赋值给它：

多维数组 - 图2

实际上arr0就获取了ns数组的第0个元素。因为ns数组的每个元素也是一个数组，因此，arr0指向的数组就是{ 1, 2, 3, 4 }。在内存中，结构如下：

  1.             arr0 ─────┐
  2.                       ▼
  3.                     ┌───┬───┬───┬───┐
  4.          ┌───┐  ┌──▶│ 1 │ 2 │ 3 │ 4 │
  5. ns ─────▶│░░░│──┘   └───┴───┴───┴───┘
  6.          ├───┤      ┌───┬───┬───┬───┐
  7.          │░░░│─────▶│ 5 │ 6 │ 7 │ 8 │
  8.          ├───┤      └───┴───┴───┴───┘
  9.          │░░░│──┐   ┌───┬───┬───┬───┐
  10.          └───┘  └──▶│ 9 │10 │11 │12 │
  11.                     └───┴───┴───┴───┘

访问二维数组的某个元素需要使用array[row][col]，例如：

  1. System.out.println(ns[1][2]); // 7

二维数组的每个数组元素的长度并不要求相同，例如，可以这么定义ns数组：

  1. int[][] ns = {
  2.     { 1, 2, 3, 4 },
  3.     { 5, 6 },
  4.     { 7, 8, 9 }
  5. };

这个二维数组在内存中的结构如下：

  1.                     ┌───┬───┬───┬───┐
  2.          ┌───┐  ┌──▶│ 1 │ 2 │ 3 │ 4 │
  3. ns ─────▶│░░░│──┘   └───┴───┴───┴───┘
  4.          ├───┤      ┌───┬───┐
  5.          │░░░│─────▶│ 5 │ 6 │
  6.          ├───┤      └───┴───┘
  7.          │░░░│──┐   ┌───┬───┬───┐
  8.          └───┘  └──▶│ 7 │ 8 │ 9 │
  9.                     └───┴───┴───┘

要打印一个二维数组，可以使用两层嵌套的for循环：

  1. for (int[] arr : ns) {
  2.     for (int n : arr) {
  3.         System.out.print(n);
  4.         System.out.print(', ');
  5.     }
  6.     System.out.println();
  7. }

或者使用Java标准库的Arrays.deepToString()：

多维数组 - 图3

三维数组

三维数组就是二维数组的数组。可以这么定义一个三维数组：

  1. int[][][] ns = {
  2.     {
  3.         {1, 2, 3},
  4.         {4, 5, 6},
  5.         {7, 8, 9}
  6.     },
  7.     {
  8.         {10, 11},
  9.         {12, 13}
  10.     },
  11.     {
  12.         {14, 15, 16},
  13.         {17, 18}
  14.     }
  15. };

它在内存中的结构如下：

  1.                               ┌───┬───┬───┐
  2.                    ┌───┐  ┌──▶│ 1 │ 2 │ 3 │
  3.                ┌──▶│░░░│──┘   └───┴───┴───┘
  4.                │   ├───┤      ┌───┬───┬───┐
  5.                │   │░░░│─────▶│ 4 │ 5 │ 6 │
  6.                │   ├───┤      └───┴───┴───┘
  7.                │   │░░░│──┐   ┌───┬───┬───┐
  8.         ┌───┐  │   └───┘  └──▶│ 7 │ 8 │ 9 │
  9. ns ────▶│░░░│──┘              └───┴───┴───┘
  10.         ├───┤      ┌───┐      ┌───┬───┐
  11.         │░░░│─────▶│░░░│─────▶│10 │11 │
  12.         ├───┤      ├───┤      └───┴───┘
  13.         │░░░│──┐   │░░░│──┐   ┌───┬───┐
  14.         └───┘  │   └───┘  └──▶│12 │13 │
  15.                │              └───┴───┘
  16.                │   ┌───┐      ┌───┬───┬───┐
  17.                └──▶│░░░│─────▶│14 │15 │16 │
  18.                    ├───┤      └───┴───┴───┘
  19.                    │░░░│──┐   ┌───┬───┐
  20.                    └───┘  └──▶│17 │18 │
  21.                               └───┴───┘

如果我们要访问三维数组的某个元素，例如，ns[2][0][1]，只需要顺着定位找到对应的最终元素15即可。

理论上，我们可以定义任意的N维数组。但在实际应用中，除了二维数组在某些时候还能用得上，更高维度的数组很少使用。

练习

使用二维数组可以表示一组学生的各科成绩，请计算所有学生的平均分：

多维数组 - 图4

从多维数组 - 图5下载练习：计算平均分 （推荐使用IDE练习插件快速下载）

小结

二维数组就是数组的数组，三维数组就是二维数组的数组；

多维数组的每个数组元素长度都不要求相同；

打印多维数组可以使用Arrays.deepToString()；

最常见的多维数组是二维数组，访问二维数组的一个元素使用array[row][col]。

读后有收获可以支付宝请作者喝咖啡：

多维数组 - 图6