如果数据是线性的，则可以使用一维数组。但是，要处理多层数据，我们必须使用多维数组。Java中的二维数组是多维数组的最简单形式。

Java中的二维数组声明

以下代码段显示了Java编程语言中的二维数组声明：

Data_Type[][] Array_Name;

• Data_type： 决定要接受的元素类型。例如，如果我们要存储整数值，则数据类型将声明为int。如果我们要存储浮点值，那么数据类型将是浮点的。
• Array_Name： 这是将其赋予此Java二维数组的名称。例如，汽车，学生，年龄，标记，部门，员工等。

同样，可以声明二维数组的剩余类型：

int [][] anIntegerArray; // declaring an two dimensional array of Integers
byte[][] anByteArray; // declaring an two dimensional array of Bytes
short[][] anShortArray; // declaring an two dimensional array of Shorts
long[][] anLongArray; // declaring an two dimensional array of Longs
float[][] anFloatArray; // declaring an two dimensional array of Floats
double[][] anDoubleArray; // declaring an two dimensional array of Doubles
boolean[][] anBooleanArray; // declaring an two dimensional array of Booleans
char[][] anCharArray; // declaring an two dimensional array of Chars
String[][] anStringArray; // declaring an two dimensional array of Strings

用Java创建二维数组

为了用Java创建二维数组，我们必须使用New运算符，如下所示：

Data_Type[][] Array_Name = new int[Row_Size][Column_Size];

如果我们观察以上二维数组代码片段，

• Row_Size： 数组可以存储的行元素数。例如，Row_Size = 5，则该数组将具有五行。
• Column_Size： 数组可以存储的Column元素数。例如，Column_Size = 6，则该数组将具有6列。

如果您已经用Java初始化了一个二维数组，那么

double [][] anStudentArray; // Declaration of Two dimensional array in java 

// Crating an Java two dimensional Array
anStudentArray = new int[5][3];

例如，

double [][] Employees = new double[5][3];

1. 在这里，我们使用double作为数据类型来声明Java中的二维数组。这意味着，上面的数组将仅接受双精度值，并且，如果您尝试添加浮点值，则将引发错误。
2. 员工是二维数组的名称
3. 数组的行大小为5，这表示Employees数组将仅接受5个double值作为行。
   • 如果我们尝试存储5个以上的值，则将引发错误。
   • 我们可以存储少于5个示例。例如，如果我们存储2个整数值，则其余2个值将被初始化为默认值（其中0）。
4. 数组的列大小为3。这意味着Employees数组将只接受3个整数值作为列。
   • 如果我们尝试存储3个以上，则将引发错误。
   • 我们可以存储少于3个。例如，如果我们存储1个整数，则其余2个值将被初始化为默认值（哪个为0）。

Java中的二维数组的初始化

我们可以通过多种方式初始化Java二维数组。请参考数组和多维数组中的Java编程。

二维阵列优先方法

在Java中声明和创建二维数组

int[][] Student_Marks = new int[2][3];

更传统地初始化Array元素。

Student_Marks[0][0] = 15; // Initializing Array elements at position [0][0]
Student_Marks[1][1] = 45; // Initializing Array elements at position [1][1]
Student_Marks[2][1] = 65; // Initializing Array elements at position [2][1]

Java二维数组第二种方法

声明和创建二维数组的第二种方法

int[][] Student_Marks = new int[2][];

在这里，我们没有提到列的大小。但是，Jcompiler足够智能，可以通过检查列内的元素数量来计算大小。

Java二维数组第三种方法

int[][] Employees = { {10, 20, 30}, {15, 25, 35}, {22, 44, 66}, {33, 55, 77} };

在这里，我们没有提到行大小和列大小。但是，编译器足够智能，可以通过检查行和列中的元素数量来计算大小。

第四种方法

以上三种方式在Java中将少量元素存储到二维数组中是很好的，如果我们要存储100行或50列值该怎么办。使用上述任何一种方法添加所有这些方法将是一场噩梦。为了解决这个问题，我们可以在 这里使用 Nested For Loop概念：

int rows, columns;
int[][] Employees = new int[100][50];

for (rows = 0; rows < 100 ; rows++) {
	for (columns = 0; columns < 50; columns++) {
		Employees[rows][columns] = rows + columns;
	}
}

提示：为了将元素存储在Java二维数组中，我们可以使用For循环，While循环和Do While循环

Java中二维数组的第五种方法

int[][] anIntegerArray = new int[5][3];
anIntegerArray[0][0] = 10;
anIntegerArray[0][1] = 20;
anIntegerArray[0][2] = 30;

在这里，我们声明了一个Java二维数组，大小为5行* 3列，但是我们只为一行分配了值。在这种情况下，剩余值分配为默认值（在这种情况下为0）。

访问Java二维数组元素

在Java编程中，我们可以使用索引位置来访问二维数组元素。使用索引，我们可以访问或更改/更改二维数组中存在的每个单独元素。

Java二维数组的索引值从0开始，到n-1结束，其中n是行或列的大小。例如，如果一个int [] [] Array_name = new int [6] [4]将存储6个行元素和4个列元素。

为了访问或修改1个ST值使用ARRAY_NAME [0] [0]，以访问或改变2次第3行第三列的值，然后使用ARRAY_NAME [1] [2]和访问的6个行4个列，然后使用ARRAY_NAME [ 5] [3]。让我们看一下二维数组的示例，以更好地理解：

package ArrayDefinitions;

public class AccessTwoDimentionalArray {
	public static void main(String[] args) {
		int[][] StudentArray = { {12, 22, 33},{45, 65, 95},{442, 444, 446},{785, 786, 787}};

		System.out.println("Element at StudentArray[0][0] = " + StudentArray[0][0]);
		System.out.println("Element at StudentArray[0][1] = " + StudentArray[0][1]);
		System.out.println("Element at StudentArray[0][2] = " + StudentArray[0][2]);
		System.out.println("Element at StudentArray[1][0] = " + StudentArray[1][0]);
		System.out.println("Element at StudentArray[1][1] = " + StudentArray[1][1]);
		System.out.println("Element at StudentArray[1][2] = " + StudentArray[1][2]);
		System.out.println("Element at StudentArray[2][0] = " + StudentArray[2][0]);
		System.out.println("Element at StudentArray[2][1] = " + StudentArray[2][1]);
		System.out.println("Element at StudentArray[2][2] = " + StudentArray[2][2]);
	}
}

为了处理大量的行和列，我们必须使用 For loop。让我们使用For循环访问上述数组StudentArray [4] [3]。

int rows, columns;

for (rows = 0; rows < 4; rows++) {
     for (columns = 0; columns < 3; columns++) {
	System.out.format("%d", StudentArray[rows][columns]);
     }
}

Java二维数组示例

在此Java二维数组程序中，我们将声明2个二维数组。

接下来，我们用一些值初始化它们。然后，我们将再声明一个二维数组，以存储这两个数组的和。

// Two Dimensional Array in Java Example 
package ArrayDefinitions;

public class TwoDimentionalArray {
	public static void main(String[] args) {
		int[][] a = { {15, 25, 35}, {45, 55, 65} };
		int[][] b = {{12, 22, 32}, {55, 25, 85} };
		int[][] Sum = new int[2][3];
		int rows, columns;
		
		for(rows = 0; rows < a.length; rows++) {
			for(columns = 0; columns < a[0].length; columns++) {
				Sum[rows][columns] = a[rows][columns] + b[rows][columns];  
			}			
		}
		System.out.println("Sum Of those Two Arrays are: ");
		for(rows = 0; rows < a.length; rows++) {
			for(columns = 0; columns < a[0].length; columns++) {
				System.out.format("%d \t", Sum[rows][columns]);
			}
			System.out.println("");
		}
	}
}

在这个二维数组程序中，首先，我们声明2个大小为[2]，[3]的两个二维数组a，b，并使用一些随机值进行初始化。我们还声明了一个空数组size [2]，[3]

int[][] a = { {15, 25, 35}, {45, 55, 65} };
int[][] b = {{12, 22, 32}, {55, 25, 85} };
int[][] Sum = new int[2][3];

下面的 For循环 将帮助迭代a和b数组中存在的每个单元格。for循环内的条件（行<a.length）将确保Jcompiler不超过数组行的限制。此外，（行<a [0] .length）将确保编译器不会超出数组列的限制。

提示： a.length用于查找行的长度（第一维），而a [0] .length用于查找行的长度（第二维）。

for(rows = 0; rows < a.length; rows++) {
	for(columns = 0; columns < a[0].length; columns++) {
		Sum[rows][columns] = a[rows][columns] + b[rows][columns];  
	}			
}

让我们看看Java二维数组程序在迭代方面的执行

行优先迭代

该行的值将为0，并且条件（行<2）为True。因此，它将进入第二循环。

列优先迭代

列的值为0，条件（列<3）为True。因此，它将开始在循环内执行语句，直到条件失败为止。

• Sum [rows] [columns] = a [rows] [columns] + b [rows] [columns];
• 总和[0] [0] = a [0] [0] + b [0] [0]；
• 总和[0] [0] = 15 + 12;
• 总和[0] [0] = 27；

列的值增加1

列第二迭代

列的值为1，条件（列<3）为True。由于我们没有退出内部循环（列循环），因此行值仍为0。

• 总和[0] [1] = a [0] [1] + b [0] [1]；
• 总和[0] [1] = 25 + 22 = 47;

列的值增加1

列3次迭代

列的值为2，条件（列<3）为True。由于我们没有退出内部循环，因此行值将为0。

• 总和[0] [2] = a [0] [2] + b [0] [2];
• 总和[0] [2] = 35 + 32 = 67;

增量后，列的值将为3，条件（列<3）将失败。因此它将退出循环。

现在，行的值将增加一并开始第二行迭代。

第二行第二迭代

该行的值为1，条件（行<2）为True。因此，它将进入第二循环。

列优先迭代

列的值为0，条件（列<3）为True。因此，它将开始在循环内执行语句，直到条件失败为止。

• Sum [rows] [columns] = a [rows] [columns] + b [rows] [columns];
• 总和[1] [0] = a [1] [0] + b [1] [0]；
• 总和[1] [0] = 45 + 55;
• 总和[1] [0] = 100；

列的值增加1

列第二迭代

列的值为1，条件（列<3）为True。由于我们没有退出Columns循环，因此行值将为1

• 和[1] [1] = a [1] [1] + b [1] [1]；
• 总和[1] [1] = 55 + 25;
• 总和[1] [1] = 80;

列的值增加1

列3次迭代

列的值为2，条件（列<3）为True。由于我们没有退出内部循环（列循环），因此行值将为1。

• 和[1] [2] = a [1] [2] + b [1] [2] = 65 + 85;
• 总和[1] [2] = 150；

增量后，列的值将为3，条件（列<3）将失败。因此它将退出循环。现在行的值将增加1。这意味着行=2。条件（行<2）将失败。因此，它将退出循环。

如上所述，下一个for循环将遍历。但是，它不是使用求和法，而是使用其中的system.out.format语句以逗号分隔的方式逐一显示值。

for(rows = 0; rows < a.length; rows++) {
	for(columns = 0; columns < a[0].length; columns++) {
		System.out.format("%d \t", Sum[rows][columns]);
	}
	System.out.println("");
}

Java二维数组（Sum数组）的最终输出是：

Sum [2] [3] = {{27，47，67}，{100，80，150}};