java获取二维数组长度
 
二维数组定义：int array[][] = new int[3][4];
 获取行数： int rowLength = array.length;//3
 获取列数： int colLength = array[0].length;//4
 
在二维转置矩阵中的应用
 
    public int[][] transpose(int[][] A) {
        int x=A.length;
        int y=A[0].length;
        int[][] B=new int[y][x];
        for(int i=0;i<x;i++){
            for(int j=0;j<y;j++){
                B[j][i]=A[i][j];
            }
        }

        return B;
    }
}

Java获取二维数组行列长度
 
二维数组定义：int array[][] = new int[3][3];
 获取行数： int rowLength = array.length;
 获取列数： int colLength = array[0].length;
 
二维数组的遍历
 
class Test{
	for(int i = 0; i < array.length; i++){
		for(int j = 0; j < array[i].length; j++){
			System.out.println(array[i][j);
		}
	}
}

 
java二维数组字符数组
 

  

  

 
 
Today we will look into Two-dimensional array in java. An array is like a container that can hold a certain number of values.
 
 今天，我们将研究Java中的二维数组。 数组就像可以容纳一定数量值的容器。 
 
 
 Java中的二维数组 (Two Dimensional Array in Java)
 
 
Let’s look at a few examples of defining java two-dimensional array or 2d array.
 
 让我们看一些定义Java二维数组或2d数组的示例。 
 
 

 
 
 
 基本类型的Java二维数组 (Java Two Dimensional Array of primitive type)
 
 
int[][] arr = new int[2][3];
for (int i = 0; i < arr.length; i++) {
	for (int j = 0; j < arr[i].length; j++) {
		arr[i][j] = j;
		System.out.print(arr[i][j] + " ");
	}
	System.out.println("");
}
 
 Java二维对象数组 (Java Two Dimensional Array of Objects)
 
 
String[][] arrStr = new String[3][4];
for (int i = 0; i < arrStr.length; i++) {
	for (int j = 0; j < arrStr[i].length; j++) {
		arrStr[i][j] = "Str" + j;
		System.out.print(arrStr[i][j] + " ");
	}
	System.out.println("");
}
 
So we can define a two dimensional array of primitive data types as well as objects. If you look at the above examples, two dimensional array looks like a matrix, something like below image.
 
 因此，我们可以定义原始数据类型和对象的二维数组。 如果看上面的例子，二维数组看起来像矩阵，就像下面的图像。 
 
 
However, in Java, there is no concept of a two-dimensional array. A two-dimensional array in java is just an array of array. So below image correctly defines two-dimensional array structure in java.
 
 但是，在Java中，没有二维数组的概念。 Java中的二维数组只是数组的数组。 因此，下面的图像在Java中正确定义了二维数组结构。 
 
 

  

  

 
 

  

  

 
 
 Java多维数组示例 (Java multidimensional array example)
 
 
Now if two-dimensional array in java is an array-of-arrays, then it should also support non-symmetric sizes as shown in below image.
 
 现在，如果java中的二维数组是一个数组数组，那么它也应该支持非对称大小，如下图所示。 
 
 
Well, it’s absolutely fine in java. Below is an example program that depicts above multidimensional array.
 
 好吧，在Java中绝对没问题。 以下是描述上述多维数组的示例程序。 
 
 
public class MultidimensionalArrayExample {

	public static void main(String[] args) {

		// creating and initializing two dimensional array with shortcut syntax
		int[][] arrInt = { { 1, 2 }, { 3, 4, 5 } };
		for (int i = 0; i < arrInt.length; i++) {
			for (int j = 0; j < arrInt[i].length; j++) {
				System.out.print(arrInt[i][j] + " ");
			}
			System.out.println("");
		}

		// showing multidimensional arrays initializing
		int[][] arrMulti = new int[2][]; // yes it's valid

		arrMulti[0] = new int[2];
		arrMulti[1] = new int[3];

		arrMulti[0][0] = 1;
		arrMulti[0][1] = 2;
		arrMulti[1][0] = 3;
		arrMulti[1][1] = 4;
		arrMulti[1][2] = 5;
		for (int i = 0; i < arrInt.length; i++) {
			for (int j = 0; j < arrInt[i].length; j++) {
				System.out.print(arrInt[i][j] + " ");
			}
			System.out.println("");
		}
	}
}
 
If we run the above program, it will produce the following output.
 
 如果我们运行上面的程序，它将产生以下输出。 
 
 
1 2 
3 4 5 
1 2 
3 4 5
 
That’s all about two-dimensional array in java. In a similar way, we can define a multidimensional array in java too.
 
 这就是Java中的二维数组。 以类似的方式，我们也可以在java中定义多维数组。 
 
 
Reference: Java Array Oracle page
 
 参考： Java Array Oracle页面 
 
 

  
翻译自: https://www.journaldev.com/747/two-dimensional-array-java
 
 
java二维数组字符数组

Java编程语言中的二维数组不过是数组数组。在Java二维数组中，数据存储在行和列中，我们可以使用行索引和列索引（例如Excel File）访问记录。
 
 
 

   
 
 
 
如果数据是线性的，则可以使用一维数组。但是，要处理多层数据，我们必须使用多维数组。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];
 
 
在这里，我们使用double作为数据类型来声明Java中的二维数组。这意味着，上面的数组将仅接受双精度值，并且，如果您尝试添加浮点值，则将引发错误。
员工是二维数组的名称
数组的行大小为5，这表示Employees数组将仅接受5个double值作为行。 
   
如果我们尝试存储5个以上的值，则将引发错误。
我们可以存储少于5个示例。例如，如果我们存储2个整数值，则其余2个值将被初始化为默认值（其中0）。
数组的列大小为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}};