Java多维数组概念

Question

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

  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

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

如果你用int[][] xyz = new int[2][3]; initiaze 你的xyz数组int[][] xyz = new int[2][3]; ，您创建了一个包含两个元素的数组，每个元素都是一个包含 3 个元素的int数组。

没有什么可以阻止您稍后将 4 个元素的int数组分配给xyz[0] ，就像没有什么可以阻止您将 6 个元素的int数组分配给y 。 数组变量可以保存对相同元素类型的任何数组的引用。

Answer 2

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

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

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

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

Answer 3

就像@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 4

这声明了一个变量，用于保存对二维 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};

将 xyz 中的第一个引用替换为 y 中存储的引用。 您现在有一个“数组”，其中“行”的长度不等。

xyz[0]=y;

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

System.out.println(y.length);

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

System.out.println(xyz.length); 

在 y 中搜索 11 - 坏主意，因为必须在排序数组上进行二分搜索。

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 的第一行按排序顺序打印——记住这句话用存储在 y 中的引用替换 xyz 中的第一个引用，sort 对 y 指向的对象和 xyz 的第一行进行排序。

Answer 5

请有人解释一下，当大小为 3 时，它是如何允许存储 4 个元素的？

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

视觉上是这样的（当然也可以看成3行2列）：

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

这里的关键概念是，Java 中的二维数组表示数组的数组。 由于它是一个数组数组，因此每个“行”都包含一个数组本身。 因此，您可以为每个“行”分配任何新数组。

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

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

---

一维数组

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

---

二维数组

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

Answer 6

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

多维数组是数组的数组。 查看更多。

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

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

当您像int xyz[][] = new int[2][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第一个数组重新分配给y 。 这看起来像重新分配变量，您可以创建

int a = 10;

然后您可以像这样将数字重新分配给变量a ：

a = 45;

所以数组分配是相似的。 首先 Java 赋值，然后你重新赋值。 首先 Java 分配默认值0s ，然后创建一维数组并将y重新分配给xyz[0] 。 这就是为什么你可以定义不同大小的数组，尽管有固定大小的元素。

Answer 7

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