在Java中创建二维数组的语法

考虑:

int[][] multD = new int[5][];
multD[0] = new int[10];

这就是创建5行10列的二维数组的方法吗?

我在网上看到了这段代码，但语法没有意义。

1646665 次浏览
小开

创建带有5行和10列的二维数组最常见的习惯用法是:

int[][] multD = new int[5][10];

或者，你也可以使用下面的代码，它更类似于你所拥有的，尽管你需要显式地初始化每一行:

int[][] multD = new int[5][];
for (int i = 0; i < 5; i++) {
multD[i] = new int[10];
}
小开

试一试:

int[][] multD = new int[5][10];
注意，在你的代码中，只有2D数组的第一行被初始化为0。 第二行到第五行根本不存在。如果你试图打印它们，你会得到null为每一个
小开
最佳答案

试试下面的方法:

int[][] multi = new int[5][10];

．.． 这是类似这样的东西的简称:

int[][] multi = new int[5][];
multi[0] = new int[10];
multi[1] = new int[10];
multi[2] = new int[10];
multi[3] = new int[10];
multi[4] = new int[10];

注意，每个元素都将被初始化为int， 0的默认值，因此上述元素也等价于:

int[][] multi = new int[][]{
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};
小开

您可以按照其他人提到的方法创建它们。还有一点需要补充:你甚至可以用每一行创建一个倾斜的二维数组，不一定有相同数量的列，就像这样:

int array[][] = new int[3][];
array[0] = new int[3];
array[1] = new int[2];
array[2] = new int[5];
小开

我们可以声明一个二维数组，并在声明时直接将元素存储为:

int marks[][]=\{\{50,60,55,67,70},{62,65,70,70,81},{72,66,77,80,69}};

这里int表示存储在数组中的整数类型元素，数组名称为'marks'。int是“{”和“}”大括号内表示的所有元素的数据类型，因为数组是具有相同数据类型的元素的集合。

回到上面写的语句:每一行元素都应该写在花括号内。行和每行中的元素应该用逗号分隔。

现在观察语句:您可以得到3行5列，因此JVM创建了3 * 5 = 15个内存块。这些块可以分别称为:

marks[0][0]  marks[0][1]  marks[0][2]  marks[0][3]  marks[0][4]
marks[1][0]  marks[1][1]  marks[1][2]  marks[1][3]  marks[1][4]
marks[2][0]  marks[2][1]  marks[2][2]  marks[2][3]  marks[2][4]
< p > < br > 注意:< br > 如果要存储n元素，则数组索引从0开始，到n - 1结束。 创建二维数组的另一种方法是先声明数组，然后使用new操作符为它分配内存 
int marks[][];           // declare marks array
marks = new int[3][5];   // allocate memory for storing 15 elements

将上述两者结合起来，我们可以得到:

int marks[][] = new int[3][5];
小开 
int rows = 5;
int cols = 10;


int[] multD = new int[rows * cols];


for (int r = 0; r < rows; r++)
{
for (int c = 0; c < cols; c++)
{
int index = r * cols + c;
multD[index] = index * 2;
}
}

享受吧!

小开

在Java中，二维数组可以声明为与一维数组相同。在一维数组中，你可以这样写

  int array[] = new int[5];

其中int是一个数据类型，array[]是一个数组声明，new array是一个数组，它的对象有五个索引。

这样，就可以像下面这样编写一个二维数组。

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

这里array是一个int型数据类型。我首先声明了该类型的一维数组，然后创建了一个3行4列的数组。

在代码中

int[][] multD = new int[5][];
multD[0] = new int[10];

表示您已经创建了一个二维数组，包含5行。在 第一行有10列。在Java中，您可以根据需要选择每行的列大小

小开 
int [][] twoDim = new int [5][5];


int a = (twoDim.length);//5
int b = (twoDim[0].length);//5


for(int i = 0; i < a; i++){ // 1 2 3 4 5
for(int j = 0; j <b; j++) { // 1 2 3 4 5
int x = (i+1)*(j+1);
twoDim[i][j] = x;
if (x<10) {
System.out.print(" " + x + " ");
} else {
System.out.print(x + " ");
}
}//end of for J
System.out.println();
}//end of for i
小开

也可以用以下方式声明它。这不是什么好设计，但很管用。

int[] twoDimIntArray[] = new int[5][10];
小开

试试这个方法:

int a[][] = \{\{1,2}, {3,4}};


int b[] = {1, 2, 3, 4};
小开

这些类型的数组在Java中被称为锯齿数组:

int[][] multD = new int[3][];
multD[0] = new int[3];
multD[1] = new int[2];
multD[2] = new int[5];

在这个场景中，数组的每一行都包含不同数量的列。在上面的例子中，第一行包含三列，第二行包含两列，第三行包含五列。你可以在编译时初始化这个数组，如下所示:

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

你可以很容易地迭代数组中的所有元素:

for (int i = 0; i<multD.length; i++) {
for (int j = 0; j<multD[i].length; j++) {
System.out.print(multD[i][j] + "\t");
}
System.out.println();
}
小开

实际上，Java并没有数学意义上的多维数组。Java所拥有的只是数组的数组，每个元素也是数组的数组。这就是为什么初始化它的绝对要求是第一个维度的大小。如果指定了其余参数，则它将创建一个填充默认值的数组。

int[][]   ar  = new int[2][];
int[][][] ar  = new int[2][][];
int[][]   ar  = new int[2][2]; // 2x2 array with zeros

这也给了我们一个怪癖。子数组的大小不能通过添加更多元素来改变，但是我们可以通过分配任意大小的新数组来做到这一点。

int[][]   ar  = new int[2][2];
ar[1][3] = 10; // index out of bound
ar[1]    = new int[] {1,2,3,4,5,6}; // works
小开

如果你想要一些动态和灵活的东西(即你可以添加或删除列和行)，你可以尝试" ArrayList of ArrayList"

public static void main(String[] args) {


ArrayList<ArrayList<String>> arrayListOfArrayList = new ArrayList<>();


arrayListOfArrayList.add(new ArrayList<>(List.of("First", "Second", "Third")));
arrayListOfArrayList.add(new ArrayList<>(List.of("Fourth", "Fifth", "Sixth")));
arrayListOfArrayList.add(new ArrayList<>(List.of("Seventh", "Eighth", "Ninth")));
arrayListOfArrayList.add(new ArrayList<>(List.of("Tenth", "Eleventh", "Twelfth")));


displayArrayOfArray(arrayListOfArrayList);
addNewColumn(arrayListOfArrayList);
displayArrayOfArray(arrayListOfArrayList);
arrayListOfArrayList.remove(2);
displayArrayOfArray(arrayListOfArrayList);
}


private static void displayArrayOfArray(ArrayList<ArrayList<String>> arrayListOfArrayList) {
for (int row = 0; row < arrayListOfArrayList.size(); row++) {
for (int col = 0; col < arrayListOfArrayList.get(row).size(); col++) {
System.out.printf("%-10s", arrayListOfArrayList.get(row).get(col));
}
System.out.println("");
}
System.out.println("");
}


private static void addNewColumn(ArrayList<ArrayList<String>> arrayListOfArrayList) {
for (int row = 0; row < arrayListOfArrayList.size(); row++) {
arrayListOfArrayList.get(row).add("added" + row);
}
}

输出:

First     Second    Third
Fourth    Fifth     Sixth
Seventh   Eighth    Ninth
Tenth     Eleventh  Twelfth


First     Second    Third     added0
Fourth    Fifth     Sixth     added1
Seventh   Eighth    Ninth     added2
Tenth     Eleventh  Twelfth   added3


First     Second    Third     added0
Fourth    Fifth     Sixth     added1
Tenth     Eleventh  Twelfth   added3

提交答案