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。