Java 多维数组 | 未读代码

多维数组

在 Java 中，多维数组是由多个一维数组组成的数组。Java 的多维数组可以支持两个或多个维度。

多维数组也可以表达为数组的元素也是数组这种形式，它的结构像下面这样。

Java 多维数组

多维数组创建

Java 中定义多维数组的语法如下：

dataType[][] arrayName = new dataType[row][column];

其中，dataType 表示数组中元素的数据类型，arrayName 是数组的名称，row 和 column 分别表示数组的行数和列数。例如，定义一个二维数组可以使用以下代码：

int[][] myArray = new int[3][3];

这个二维数组有3 行3 列，如果用二维表格展示，如下图：

Java 二维数组

可以使用以下方式为数组中的元素赋值：

myArray[0][0] =1;
myArray[0][1] =2;
myArray[0][2] =3;

myArray[1][0] =5;
myArray[1][1] =6;
myArray[1][2] =7;

myArray[2][0] =9;
myArray[2][1] =10;
myArray[2][2] =11;

Java 中的多维数组是一个对象，可以使用 length 属性获取数组的长度。例如，myArray.length 返回 3，myArray[0].length 也会返回 3。

Java 还支持三维数组、四维数组等多维数组。例如，定义一个三维数组可以使用以下代码：

int[][][] myArray = new int[3][4][5];

Java 的多维数组也支持定义时就初始化，例如，以下代码定义了一个二维数组并将它们初始化为指定的值：

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

多维数组访问

Java 的多维数组可以使用如下方式进行访问：x[array_index][row_index][column_index].

也可以使用循环结构来遍历数组中的元素，例如：

int[][] myArray = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
for (int i = 0; i < myArray.length; i++) {
    for (int j = 0; j < myArray[i].length; j++) {
        System.out.print(myArray[i][j] + " ");
    }
    System.out.println();
}
// 输出：
// 1 2 3 
// 4 5 6 
// 7 8 9

这段代码使用了双重循环结构来遍历二维数组中的所有元素，并将它们输出到控制台。

当然，也可以指定指定下标来访问元素。

System.out.println(myArray[0][0]); // 输出1
System.out.println(myArray[0][1]); // 输出2
System.out.println(myArray[1][0]); // 输出4

可以看出，Java 的多维数组使用方便，支持多种操作，是 Java语言编程中重要的数据类型之一。

三维数组

三维数组可以看作是数组中每个元素都是二维数组的数组，像下面的图，三个表每个表都是一个二维数组，他们合并起来就是一个三维数组。三维数组使用 x[i][j][k] 的形式进行访问。

三维数组

三维数组创建

创建一个每个数组长度都为 3 的三维数组。

int[][] myArray1 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[][] myArray2 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[][] myArray3 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[][][] array3d = {myArray1, myArray2, myArray3};

三维数组的访问

for (int i = 0; i < array3d.length; i++) {
    for (int j = 0; j < array3d[i].length; j++) {
        for (int k = 0; k < array3d[i][j].length; k++) {
            System.out.print(array3d[i][j][k] + " ");
        }
        System.out.println();
    }
    System.out.println("-----");
}
System.out.println(array3d[1][1][1]);

输出：

多维数组的 clone

在 Java 中，多维数组也可以使用 clone() 方法进行复制。clone() 方法返回一个新的数组对象，该对象包含与原始数组相同的元素和大小。

多维数组的 clone() 方法可以使用以下语法：

dataType[][] newArray = oldArray.clone();

其中，oldArray 是要复制的原始数组，newArray 是复制后的新数组对象。

需要注意的是，clone() 方法是一个浅拷贝，如果原始数组包含对象引用，则克隆的新数组将包含相同的对象引用，而不是把他们复制一份，这个特性在某些情况下可能会导致问题，因此需要谨慎使用。

Java 多维数组 clone

下面演示多维数组的浅拷贝现象。

int intArray[][] = { { 1, 2, 3 }, { 4, 5 } };
int cloneArray[][] = intArray.clone();
// 输出：false
System.out.println(intArray == cloneArray);

// 因为是浅拷贝，所以元素引用相同，输出 true
System.out.println(intArray[0] == cloneArray[0]);
System.out.println(intArray[1] == cloneArray[1]);

交错（Jagged）数组

上面介绍的 Java 的多维数组中，有一个特点，就是数组的每个元素数组的长度是固定相等的，且数组长度不能改变。但是其实对于多维数组来讲，每个元素只要是数组就行了，并不关心数组的元素数组的具体长度。

Java中的交错数组是一种特殊的二维数组，它的每一行的长度可以不同。也就是说，Java中的交错数组是由多个不同长度的一维数组组成的，交错数组不是一个矩形。

其实交错数组这个名字并不好理解，我们也可以称为参差不齐的数组，这样比较形象。如果用图表示，会是像下面这样。

Java 交错数组

交错（Jagged）数组创建

交错数组的创建有多种方式，下面给出常见的几种创建方法。

// 方式1
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[] {1, 2, 3};
jaggedArray[1] = new int[] {4, 5};
jaggedArray[2] = new int[] {6, 7, 8, 9};

// 方式2
int[][] arrName1 = new int[][] {
    new int[] {10, 20, 30, 40},
    new int[] {50, 60, 70, 80, 90, 100},
    new int[] {110, 120}
};
// 方式3
int[][] arrName2 = {
    new int[] {10, 20, 30, 40},
    new int[] {50, 60, 70, 80, 90, 100},
    new int[] {110, 120}
};
// 方式4
int[][] arrName3 = {
    {10, 20, 30, 40},
    {50, 60, 70, 80, 90, 100},
    {110, 120}
};

个人觉得方式 4 的创建方式比较直观，容易理解。在方式 1中声明了一个长度为3的交错数组，然后对每一行进行了初始化，第一行包含3个元素，第二行包含2个元素，第三行包含4个元素。

交错（Jagged）数组访问

在访问交错数组中的元素时，可以使用双重循环来遍历数组，第一重循环用于遍历每一行，第二重循环用于遍历每一行中的元素。如下所示：

for (int i = 0; i < jaggedArray.length; i++) {
    for (int j = 0; j < jaggedArray[i].length; j++) {
        System.out.print(jaggedArray[i][j] + " ");
    }
    System.out.println();
}

输出：

1 2 3 
4 5 
6 7 8 9

交错（Jagged）数组优点

交错数组作为一种特殊的数组，为什么我们要花篇幅对他进行介绍呢，是因为交错数组有以下几个优点。

灵活性：交错数组的每一行长度可以不相同，这使得它非常适合处理不规则的数据。如果我们事需要存储不同长度的数组，或者事先不知道子数组的长度，那么使用交错数组可以更加灵活地处理数据。
节约内存：与普通的二维数组相比，交错数组可以节约内存。因为普通的二维数组需要为每一行分配相同的长度，而交错数组只需要为每一行分配实际需要的长度。
不错的性能：对于某些操作，例如访问元素或遍历子数组，因为交错数组的内存布局更加紧凑，因此交错数组可以比矩形数组访问的更快，

一如既往，文章中代码存放在 Github.com/niumoo/javaNotes.