多维数组

• 多维数组，一般语法
• 二维数组
• 声明、创建和初始化二维数组
• 在屏幕上显示二维数组
• 二维数组的快速输出
• 二维数组的“长度”
• 使用二维数组的示例：棋盘格
• 使用二维数组的示例：矩阵乘法
• 非矩形二维数组
• 三维数组
• Java程序员实际工作中的多维数组
• 二维和三维数组的有趣问题

什么是一维 Java 数组？

数组是相同类型、基元或引用的元素的有序集合。有关数组（大部分是一维）的一般信息可以在“ Java 中的数组”一文和JavaRush课程中找到。在本文中，我们将讨论元素为其他数组的数组。这样的数组称为多维数组。元素是其他数组的数组，即数组的数组，称为二维数组。并非所有语言都具有这种结构的多维数组，但在 Java 中就是这种情况。

Java 多维数组，一般语法

一般来说，Java 中的多维数组如下所示：

Data_type[dimension1][dimension2][]..[dimensionN] array_name = new data_type[size1][size2]….[sizeN];

其中Data_type是数组中元素的类型。可以是原始的或引用的（类）。里面的括号对的数量dimension是数组的维数（在我们的例子中是 - N）。 array_name— 数组名称 size1...sizN— 数组每个维度中的元素数量。声明多维数组：

int[][] twoDimArray; //two-dimensional array
String[][][] threeDimArray; //three-dimensional array
double[][][][][] fiveDimArray; // five-dimensional array

也许这一切看起来很抽象，那么现在让我们继续讨论多维数组的具体表现——二维和三维。事实上，Java 开发人员有时会使用二维数组，而很少使用三维数组，甚至更大的数组也极为罕见。您很有可能不会遇到它们。

什么是Java二维数组？

Java中的二维数组是数组的数组，即每个单元格都包含对数组的引用。但以具有给定行数（第一维）和列数（第二维）的表格形式呈现要容易得多。所有行具有相同数量元素的二维数组称为矩形。

声明、创建和初始化二维数组

声明和创建二维数组的过程与一维数组的过程几乎相同：

int[][] twoDimArray = new int[3][4];

该数组有 3 行和 4 列。矩形二维数组的大小（它们可能不是矩形，下面会详细介绍），即元素总数可以通过行数乘以列数来确定。现在它已使用默认值进行初始化（填充）。也就是说，零。让我们用我们需要的值来填充它。

twoDimArray[0][0] = 5;//write the value 5 into the cell at the intersection of the zero row and zero column
twoDimArray[0][1] = 7; //write the value 7 into the cell at the intersection of the zero row and the first column
twoDimArray[0][2]  = 3;
twoDimArray[0][3] = 17;
twoDimArray[1][0] = 7;
twoDimArray[1][1] = 0;
twoDimArray[1][2] = 1;
twoDimArray[1][3] = 12;
twoDimArray[2][0] = 8;
twoDimArray[2][1] = 1;
twoDimArray[2][2] = 2;
twoDimArray[2][3] = 3;

与一维数组一样，您可以更快地执行初始化过程：

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};

在这两种情况下，我们都会得到一个三行四列的二维数组，并填充整数。

在屏幕上显示二维数组

执行此操作的最合乎逻辑的方法是首先逐个元素输出零线，然后是第二个，依此类推。Java中输出二维数组最常见的方法是使用两个嵌套循环。

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};//declared an array and filled it with elements
for (int i = 0; i < 3; i++) {  //go through the lines
            for (int j = 0; j < 4; j++) {//go through the columns
                System.out.print(" " + twoDimArray[i][j] + " "); //output element
            }
            System.out.println();// line wrap for the visual preservation of the tabular form
        }

二维数组的快速输出

在屏幕上显示二维数组元素列表的最短方法是使用deepToString类方法Arrays。例子：

int[][] myArray = {{18,28,18},{28,45,90},{45,3,14}};
System.out.printLn(Arrays.deepToString(myArray));

程序的结果如下： [[18, 28, 18], [28, 45, 90], [45, 3, 14]]

二维数组的“长度”

要获取一维数组的长度（即其中元素的数量），可以使用变量length。也就是说，如果我们定义一个数组int a[] = {1,2,3}，那么该操作a.length将返回 3。但是如果我们将相同的过程应用于二维数组呢？

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};
System.out.println(twoDimArray.length);

输出： 3 因此该操作输出数组中的行数。如何获取列数？如果我们处理矩形二维数组（即所有线长度相同的数组），那么我们可以应用操作twoDimArray[0].lengthor 来代替零元素（本质上是零线） - 任何其他现有的元素。我们可以这样做，因为在Java中，二维数组是数组的数组，元素零twoDimArray[0]是长度为4的数组。你可以自己检查一下。

使用二维数组的示例：棋盘格

二维数组可用于创建任何有限二维字段，例如在游戏中，特别是在国际象棋中。我们很容易将棋盘想象成一个二维数组。您可以将图形“附加”到此，但现在，让我们使用符号定义一个棋盘并将其输出到控制台。 棋盘左下方的方块被漆成黑色，下一个方块是白色的，上面的方块也是白色的。因此，每次移动到与侧面相邻的单元格时，颜色都会发生变化。要不手动而是使用算法设置国际象棋着色，您可以使用奇偶校验：如果行和列索引的总和为偶数或零，则单元格将为白色，否则为黑色。对于此检查，我们在算法中使用余数运算符 %。由于我们使用的不是图形，而是符号，因此我们将用字母W（白色）表示白色单元格，用字母B（黑色）表示黑色单元格。

//set the chessboard as a two-dimensional array
String [][] chessBoard = new String[8][8];
        for (int i = 0; i< chessBoard.length; i++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                if ((i + j) % 2 == 0) chessBoard[i][j] = "W";
                else chessBoard[i][j] = "B";
            }
        }

程序的输出如下： WBWBWBWBBWBWBWBWWBWBW BWBBWBWBWBWWBWBWBWBBW BWBWBWWBWBWBWBBWBWBWB W 一切都像在真正的棋盘上一样，你可以检查一下。 现在让我们编写一个方法来正确地对单元进行编号，而不是使用数组语言，而是使用“国际象棋”语言。棋盘上左下角的单元格称为 A1，而在我们的数组中它是chessBoard[7][0]。让我们将二维数组的每对索引与其“国际象棋”等价物关联起来。为此，我们使用两行 -“ abcdefgh”和“ 87654321”（以相反的顺序 - 为简单起见，以便棋盘 8 对应于零列）。

public static String chessBoardCoord(int a, int b) {
            String letters = "abcdefgh";
            String numbers = "87654321";
            if ((a > 7)|| (b>7)) return null; //if the number is outside the board, return the default value - null
            else return (Character.toString(letters.charAt(a)) + numbers.charAt(b)); /*charAt - a method with which we extract from the string the element under the passed number, here - under the numbers a and b. Character.toString - a method that converts the received character into a string */
        }

现在让我们使用以下方法在每个单元格中不仅显示其颜色，还显示其数量chessBoardCoord

String [][] chessBoard = new String[8][8];
        for (int i = 0; i < chessBoard.length; i++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                if ((i + j) % 2 == 0) chessBoard[i][j] = "W" + chessBoardCoord(j,i);
                else chessBoard[i][j] = "B"+ chessBoardCoord(j,i);
            }
        }

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

程序输出： Wa8 Bb8 Wc8 Bd8 We8 Bf8 Wg8 Bh8 Ba7 Wb7 Bc7 Wd7 Be7 Wf7 Bg7 Wh7 Wa6 Bb6 Wc6 Bd6 We6 Bf6 Wg6 Bh6 Ba5 Wb5 Bc5 Wd5 Be5 Wf5 Bg5 Wh5 Wa4 Bb4 Wc4 Bd4 We4 Bf4 Wg4 Bh4 Ba3 Wb3 Bc3 Wd 3 Be3 Wf3 Bg3 Wh3 Wa2 Bb2 Wc2 Bd2 We2 Bf2 Wg2 Bh2 Ba1 Wb1 Bc1 Wd1 Be1 Wf1 Bg1 Wh1 其中We2表示编号为 e2 的白色方块。

使用二维数组的示例：矩阵乘法

注意力！此示例需要矩阵的基本知识。这里对它们的介绍很少，这些信息是为那些已经研究过但有些忘记了矩阵算术的人准备的。然而，这些知识可以从开源中收集，特别是从维基百科上的文章中收集。这是使用二维数组的一个很好的例子，但是我们可以在没有它的情况下继续。因此，如果您现在从数学角度来看似乎难以理解，并且您不想深入研究它，请随意跳过该示例。如果您学习过基本线性代数，您可能已经了解了矩形数组作为矩形矩阵。 其中 a11、a12...aNN 是一些数字。图中，矩阵甚至不是矩形，而是正方形（行数等于列数，但情况并非总是如此）。在现实生活中，这样的矩阵很少遇到，但在编程和计算机科学中它们很常见。特别是，它们用于计算机图形和游戏引擎。例如，可以使用旋转矩阵对屏幕上的对象旋转到任意角度进行编程。在二维空间中，旋转矩阵如下所示： 其中 theta 是物体需要旋转的角度。相同维度的矩阵可以相互相加，并且相加是逐个元素进行的（我们添加具有相同索引的元素）。但矩阵乘法的运算却不太熟悉。因此，只有当第一个矩阵的列数与第二个矩阵的行数一致时，才能进行矩阵相乘并获得结果矩阵。结果矩阵将具有与第一个矩阵相同的行数和与第二个矩阵相同的列数。乘法执行如下。让我们有一个矩阵a[l][m]和b[m][n]。作为它们相乘的结果，我们应该得到一个矩阵c[l][n]。要获得c[0][0]乘积矩阵的元素，需要将a[0][0]第一个矩阵的零行的零元素乘以第二个矩阵的零元素，然后将第一个矩阵的第一行的第一个元素乘以第一个元素第二个矩阵的第一列的值，依此类推，然后添加所有所得的乘积。

a[0][0]*b[0][0] + a[0][1]*b[1][0] + … + a[0][m-1]*b[m-1][0]

为了获得结果矩阵第一行的第二个元素，我们对第二行执行相同的过程

a[1][0]*b[0][0] + a[1][1]*b[0][1] + … + a[0][m-1]*b[m-1][0]

依此类推，直到行尾。然后我们转到下一行并重复该过程，直到用完所有行。也就是说，我们将第一个矩阵的行与第二个矩阵的列相乘。下面是矩阵乘法的代码。您可以通过检查是否符合上述行数和列数条件来补充它。

//declaring two matrices
int [][] twoDimArray1 = {{1,0,0,0},{0,1,0,0},{0,0,0,0}};
int[][] twoDimArray2 = {{1,2,3},{1,1,1},{0,0,0},{2,1,0}};

//matrix multiplication process
int[][]twoDimArray3 = new int [twoDimArray1.length][twoDimArray2[0].length];
        for (int i=0; i<twoDimArray3[0].length; i++)
            for (int j=0; j<twoDimArray3.length; j++)
                for (int k=0; k<twoDimArray1[0].length; k++)
                              twoDimArray3[i][j] = twoDimArray3[i][j] + twoDimArray1[i][k] * twoDimArray2[k][j];

//output on display
        for (int i = 0; i < twoDimArray3.length; i++) {
            for (int j = 0; j < twoDimArray3[0].length; j++) {
                System.out.print(" " + twoDimArray3[i][j] + " ");
            }
            System.out.println();
        }

程序输出以下结果： 1 2 3 1 1 1 0 0 0

非矩形二维数组

由于二维数组是Java中数组的数组，因此每个内部数组可以具有不同的长度。创建数组时，我们只能指定行数，而不能指定列数（即实际上这些相同行的长度）。让我们看一个例子。

//declaring and creating an array, specifying only the number of rows
int [][] twoDimArray = new int[5][];

//initialize the array, filling it with arrays of different lengths
        twoDimArray[0] = new int[]{1, 2, 3, 4, 5};
        twoDimArray[1] = new int[]{1,2,3,4};
        twoDimArray[2] = new int[]{1,2,3};
        twoDimArray[3] = new int[]{1,2};
        twoDimArray[4] = new int[]{1};
//display the resulting non-rectangular two-dimensional array on the screen
        for (int i = 0; i < twoDimArray.length; i++) {
            for (int j = 0; j < twoDimArray[i].length; j++) {
                System.out.print(" " + twoDimArray[i][j] + " ");
            }
            System.out.println();
        }

程序输出： 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1 因此，数组的第 0 行包含数组{1,2,3,4,5}，第四行包含数组{1}。

Java中的三维数组

按照常识和Java语言的逻辑，三维数组可以称为“数组的数组的数组”或“每个元素都是二维数组的数组”。而且，这些二维数组可以不同。例子：

// create a three-dimensional array consisting of two two-dimensional arrays
int[][][] threeDimArr = new int[2][][];
//create the first 2D array of a 5x2 3D array
        threeDimArr[0] = new int[5][2];
//create a second 2D array of a 1x1 3D array
        threeDimArr[1] = new int[1][1];

但在实践中更常见的是三维数组，其中所有三个量都被同时定义，类似于矩形二维数组。 正如我们已经提到的，三维或更多维的数组很少使用。但是，您可以使用 3D 数组编写一些有趣的内容。例如，多层停车场。每个楼层可以被认为是一个二维数组，一个停车位可以被认为是一个三维数组的特定元素。此类数组的元素可以用类型表示，如果空间空闲，则boolean值为false；如果空间被占用，则值为 true 。

//set a boolean three-dimensional array. This car park has 3 floors, each of which can accommodate 2x5 = 10 cars. By default, all cells are empty (false)
boolean[][][] parkingLot = new boolean[3][2][5];
//two cars arrived and parked on the ground floor in cell [1][0] and [1][3]
        parkingLot[0][1][0] = true;
        parkingLot[0][1][3] = true;

//Output the array to the console
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 5; k++) {
                    System.out.print("arr[" + i + "][" + j + "][" + k + "] = " + parkingLot[i][j][k] + "\t");

                }
                System.out.println();
            }
        }

二维和三维数组的有趣问题

您对 Java 中的多维数组已经有了足够的了解，如果您有信心，可以尝试解决以下一些问题。它们并不容易，但很有趣。井字游戏。设置一个 3x3 场地，安排两名轮流球员。最初，该字段是空的，并且在每个空字段中，第一个玩家可以打叉，第二个玩家可以打零。第一个收集到排列成一行、一列或对角线的三个十字或三个零的人获胜。 兰顿的蚂蚁。有一个特定的字段，分为单元格（二维数组），涂成黑色或白色（可以通过随机函数设置）。一只“蚂蚁”随机出现在一个单元格中，每一步它都可以沿四个方向之一移动到相邻的单元格，水平或垂直。蚂蚁运动规则：

• 在黑色方块上，蚂蚁必须向左转 90°，将其单元格的颜色更改为白色，然后前进到下一个方块。
• 在白色方块上，蚂蚁向右旋转 90°，将其单元格的颜色变为黑色，然后向前走到下一个方块。

n编写一个方法，在给定蚂蚁初始位置的情况下计算步数的迭代。该字段可以用零和一随机填充（或者用字母W和表示B，就像我们在棋盘示例中所做的那样）。我们还需要另外两个参数 - 蚂蚁的水平和垂直位置，以及这一步的方向（北、南、西、东），而默认情况下，蚂蚁看起来是北。您可以尝试使用三维数组来建模魔方。标准魔方有 6 个面，每个面都是彩色方块的三维阵列Color[][][] rubik = new Color[6][3][3]。然而，实现魔方并不是一项简单的任务。

有关数组的有用材料

JavaRush 上的许多文章都专门讨论数组（主要是一维数组，因为它们在实践中更常用）。注意他们。

1. Java 中的数组- 面向初学者的数组及其示例
2. Something About Arrays - 关于数组的详细文章
3. Arrays类及其使用——文章介绍了该类的一些方法Array
4. 数组是第一个专门讨论数组的 JavaRush 讲座。
5. 返回零长度数组，而不是 null - 《EffectiveProgramming》作者 Joshua Bloch 谈论如何更好地返回空数组