Question

我定义了一个整数多维数组xyz[2][3]和一个单维数组y={1,2,3,4}，然后分配xyz[0]=y，它正常工作。可以请有人解释一下当4大小时允许存储3元素的方式吗？

  int  xyz[][]= new int [2][3];
  int [] y = {18,9,10,6,12,15,3};
  xyz[0]=y;
  System.out.println(y.length);
  System.out.println(xyz.length);

  java.util.Arrays.sort(y);
  for(int k=0;k<xyz.length;k++)
  {
      for (int l=0;l<xyz[k].length;l++)
      {
          System.out.println("xyz[k][l] : "+xyz[k][l]);
      }
  }

Answer 1

二维数组就是一个数组，其元素本身就是数组。

如果使用xyz初始化int[][] xyz = new int[2][3];数组，则创建一个包含两个元素的数组，每个元素都是一个包含3个元素的int数组。

没有什么可以阻止你以后将int 4个元素的数组分配给xyz[0]，就像没有什么能阻止你分配6个元素{{1} }数组到int。数组变量可以保存对同一元素类型的任何数组的引用。

Answer 2

在Java中，多维数组是一个数组数组，而数组只是一个引用。所以，如果你说

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

您将得到一个包含两个引用的数组。每个引用最初将是对三个整数数组的引用。但是那些引用都有类型int[]，这意味着它们只是对整数数组的引用; Java中没有任何内容表明它们必须始终具有长度3.您可以使用任何int[]替换引用，即对任何其他整数数组的引用 - 或者您可以将其替换为null。

基本上，Java中的多维数组是“参差不齐的数组”，元素都可以有不同的长度（或null）。即使你将它们全部初始化为相同的长度，它们也不必保持这种状态。

Answer 3

这声明了一个用于保存对二维int数组的引用的变量。构造函数调用创建一个2乘3的int数组，并将引用存储在该变量中。六个数组元素初始化为0，xyz实际上是一个包含2个长度为3的int数组引用的数组。

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

声明一个变量来保存一个int数组，定义一个值为18，... 3的数组对象，并将引用存储在y中。

int [] y = {18,9,10,6,12,15,3};

用x中存储的引用替换xyz中的第一个引用。你现在有一个＆＃34;阵列＆＃34;用＆＃34;行＆＃34;长度不等。

xyz[0]=y;

引用长度为7的数组 - 大括号中的七个整数。

System.out.println(y.length);

xyz仍然有两个引用类型元素

System.out.println(xyz.length);

搜索11 in y - 糟糕的主意，因为二进制搜索必须在排序的数组上完成。

System.out.println(java.util.Arrays.binarySearch(y, 11));

现在排序y

java.util.Arrays.sort(y);

明显，不是吗？

for(int k=0;k<xyz.length;k++) {
   for (int l=0;l<xyz[k].length;l++) {
        System.out.println("xyz[k][l] : "+xyz[k][l]);
   }
}

第一行xyz按排序顺序打印 - 记住句子将xyz中的第一个引用替换为存储在y 中的引用，对y 指向的对象进行排序和排序一排xyz 。

Answer 4

与@Eran类似，当你执行int xyz[][] = new int [2][3];时，你基本上是在创建一个如下所示的数组：

xyz[0]和xyz[1]都是int[3]
xyz[0][0]，xyz[0][1]和xyz[0][2]都是0 （默认值为int）
xyz[1][0]，xyz[1][1]和xyz[1][2]都是0 （默认值为int）

所以它看起来像这样：

xyz = {
    { 0, 0, 0 },
    { 0, 0, 0 }
};

当您执行xyz[0] = {18,9,10,6,12,15,3}时，您要将xyz[0]从int[3]分配到int[7]，这会将多维数组更改为：

xyz[0]是int[7]
xyz[1]仍然是int[3]
xyz[0][0]是18; xyz[0][1]是9; xyz[0][2]是10; xyz[0][3]是6; xyz[0][4]是12; xyz[0][5]是15; xyz[0][6]是3
xyz[1][0]，xyz[1][1]和xyz[1][2]仍为0

现在它看起来像这样：

xyz = {
    { 18, 9, 10, 6, 12, 15, 3 },
    { 0, 0, 0 }
};

Answer 5

请有人解释一下，当尺寸为3时，如何允许存储4个元素？

这是因为当您声明int xyz[][]= new int [2][3];时，您只是创建一个大小为2的数组，并且这两个元素中的每一个都包含一个包含3个元素的数组。

看起来像这样（当然它也可以被视为3行2列）：

{0, 0, 0},
{0, 0, 0}

这里的关键概念是，Java中的2D数组意味着数组数组。因为它是一个数组数组，每个＆＃34; row＆＃34;拥有一个数组本身。因此，您可以为每个＆＃34;行＆＃34;。

分配任何新数组

这会导致Java中可能出现不规则数组。

{0},
{0, 0},
{0, 0, 0}

int的一维数组

{0, 0, 0}  //An array of int

int的二维数组

{ {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0} }  //An array of (1D array of int)

Answer 6

首先，数组是Java中的对象。变量名是对数组的引用，您可以使用索引来获取数组的元素。

多维数组是数组的数组。参见more。

在多维数组中，可以声明数组的数组。在您的示例中，已经创建了int多维数组：int xyz[][] = new int[2][3]; 2 x 3表示您有2个数组，并且两个数组都可以保留3个int数字。

初始化数组时， Java 为我们提供了数组内部的默认值。这些默认值取决于数组的 type 。在您的示例中，当您访问元素（例如xyz[1][1]或数组length范围内所需的任何元素）时，您将得到0，因为数组的类型为int，默认值为int为零。因此，您有两个位于xyz中的数组，并且在您分配值之前，这两个数组都具有3个零值元素。

当您像int xyz[][] = new int[2][3];那样进行声明和实例化时， Java 会自动使用默认值初始化xyz数组，如下所示：

xyz[0] = {0,0,0}; 

xyz[1] = {0,0,0};

然后，您定义了一个名为y;

的新一维数组。

int[] y = {18,9,10,6,12,15,3};

，并在创建y之后将其分配给xyz[0]的零索引（xyz）数组。 xyz[0]=y; // xyz[0] = {18,9,10,6,12,15,3}; 这意味着 重新分配 。因为，当您创建xyz数组时，Java会自动初始化数组的元素，换句话说，为xyz内的数组分配默认值，然后用{重新分配xyz的第一个数组{1}}。就像重新分配变量一样，您可以创建

y

然后您可以将数字重新分配给变量int a = 10;，如下所示：

所以数组分配是相似的。首先Java分配值，然后重新分配。首先，Java分配默认值a = 45;，然后创建一维数组并将0s重新分配给y。因此，尽管元素具有固定大小，仍可以定义不同大小的数组。

Answer 7

在2d数组中基本上假设xyz [row] [col]是一个矩阵，所以在矩阵中元素的总数等于row * col，因为你已经采用了xyz [2] [3]元素的总数正在进行为2 * 3 = 6。你存储了四个元素，其余两个元素都是null。在那里你可以存储6个元素。例如xyz [4] [2] =可以存储的总项目4 * 2 = 8.

Java多维数组概念

7 个答案: