多維數組

• 多維數組，一般語法
• 二維數組
• 聲明、建立和初始化二維數組
• 在螢幕上顯示二維數組
• 二維數組的快速輸出
• 二維數組的“長度”
• 使用二維數組的範例：棋盤格
• 使用二維數組的範例：矩陣乘法
• 非矩形二維數組
• 三維數組
• Java程式設計師實際工作中的多維數組
• 二維和三維數組的有趣問題

什麼是一維 Java 陣列？

數組是相同類型、基元或引用的元素的有序集合。有關數組（大部分是一維）的一般資訊可以在“ Java 中的數組”一文和JavaRush課程中找到。在本文中，我們將討論元素為其他陣列的陣列。這樣的數組稱為多維數組。元素是其他數組的數組，即數組的數組，稱為二維數組。並非所有語言都具有這種結構的多維數組，但在 Java 中就是這種情況。

Java 多維數組，一般語法

一般來說，Java 中的多維數組如下：

Data_type[dimension1][dimension2][]..[dimensionN] array_name = new data_type[size1][size2]….[sizeN];

其中Data_type是數組中元素的類型。可以是原始的或引用的（類別）。裡面的括號對的數量dimension是數組的維數（在我們的例子中是 - N）。 array_name— 陣列名稱 size1...sizN— 陣列每個維度中的元素數量。聲明多維數組：

int[][] twoDimArray; //two-dimensional array
String[][][] threeDimArray; //three-dimensional array
double[][][][][] fiveDimArray; // five-dimensional array

也許這一切看起來很抽象，那麼現在讓我們繼續討論多維數組的具體表現——二維和三維。事實上，Java 開發人員有時會使用二維數組，而很少使用三維數組，甚至更大的數組也極為罕見。您很有可能不會遇到它們。

什麼是Java二維數組？

Java中的二維數組是數組的數組，也就是每個單元格都包含對數組的參考。但以具有給定行數（第一維）和列數（第二維）的表格形式呈現要容易得多。所有行具有相同數量元素的二維數組稱為矩形。

聲明、建立和初始化二維數組

聲明和創建二維數組的過程與一維數組的過程幾乎相同：

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

該數組有 3 行和 4 列。矩形二維數組的大小（它們可能不是矩形，下面會詳細介紹），即元素總數可以透過行數乘以列數來確定。現在它已使用預設值進行初始化（填充）。也就是說，零。讓我們用我們需要的值來填充它。

twoDimArray[0][0] = 5;//write the value 5 into the cell at the intersection of the zero row and zero column
twoDimArray[0][1] = 7; //write the value 7 into the cell at the intersection of the zero row and the first column
twoDimArray[0][2]  = 3;
twoDimArray[0][3] = 17;
twoDimArray[1][0] = 7;
twoDimArray[1][1] = 0;
twoDimArray[1][2] = 1;
twoDimArray[1][3] = 12;
twoDimArray[2][0] = 8;
twoDimArray[2][1] = 1;
twoDimArray[2][2] = 2;
twoDimArray[2][3] = 3;

與一維數組一樣，您可以更快地執行初始化過程：

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};

在這兩種情況下，我們都會得到一個三行四列的二維數組，並填入整數。

在螢幕上顯示二維數組

執行此操作的最合乎邏輯的方法是先逐個元素輸出零線，然後是第二個，依此類推。Java中輸出二維數組最常見的方法是使用兩個巢狀循環。

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};//declared an array and filled it with elements
for (int i = 0; i < 3; i++) {  //go through the lines
            for (int j = 0; j < 4; j++) {//go through the columns
                System.out.print(" " + twoDimArray[i][j] + " "); //output element
            }
            System.out.println();// line wrap for the visual preservation of the tabular form
        }

二維數組的快速輸出

在螢幕上顯示二維數組元素列表的最短方法是使用deepToString類別方法Arrays。例子：

int[][] myArray = {{18,28,18},{28,45,90},{45,3,14}};
System.out.printLn(Arrays.deepToString(myArray));

程序的結果如下： [[18, 28, 18], [28, 45, 90], [45, 3, 14]]

二維數組的“長度”

要取得一維數組的長度（即其中元素的數量），可以使用變數length。也就是說，如果我們定義一個數組int a[] = {1,2,3}，那麼該操作a.length將傳回 3。但是如果我們將相同的過程應用於二維數組呢？

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};
System.out.println(twoDimArray.length);

輸出： 3 因此此操作輸出數組中的行數。如何取得列數？如果我們處理矩形二維數組（即所有線長度相同的數組），那麼我們可以應用操作twoDimArray[0].lengthor 來代替零元素（本質上是零線） - 任何其他現有的元素。我們可以這樣做，因為在Java中，二維數組是數組的數組，元素零twoDimArray[0]是長度為4的數組。你可以自己檢查一下。

使用二維數組的範例：棋盤格

二維數組可用於創建任何有限二維字段，例如在遊戲中，特別是在國際象棋中。我們很容易將棋盤想像成一個二維陣列。您可以將圖形「附加」到此，但現在，讓我們使用符號定義一個棋盤並將其輸出到控制台。 棋盤左下方的方塊漆成黑色，下一個方塊是白色的，上面的方塊也是白色的。因此，每次移動到與側面相鄰的單元格時，顏色都會改變。若要不手動而是使用演算法設定西洋棋著色，您可以使用奇偶校驗：如果行和列索引的總和為偶數或零，則儲存格將為白色，否則為黑色。對於此檢查，我們在演算法中使用餘數運算符 %。由於我們使用的不是圖形，而是符號，因此我們將用字母W（白色）表示白色單元格，並用字母B（黑色）表示黑色單元格。

//set the chessboard as a two-dimensional array
String [][] chessBoard = new String[8][8];
        for (int i = 0; i< chessBoard.length; i++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                if ((i + j) % 2 == 0) chessBoard[i][j] = "W";
                else chessBoard[i][j] = "B";
            }
        }

程式的輸出如下： WBWBWBWBBWBWBWBWWBWBW BWBBWBWBWBWWBWBWBWBBW BWBWBWWWWBWBWBWBBWBWBWB W 一切都像真正的棋盤上一樣，您可以檢查一下。 現在讓我們寫一個方法來正確地對單元進行編號，而不是使用陣列語言，而是使用「國際象棋」語言。棋盤上左下角的單元格稱為 A1，而在我們的數組中它是chessBoard[7][0]。讓我們將二維數組的每對索引與其“國際象棋”等價物關聯起來。為此，我們使用兩行 -“ abcdefgh”和“ 87654321”（以相反的順序 - 為簡單起見，以便棋盤 8 對應於零列）。

public static String chessBoardCoord(int a, int b) {
            String letters = "abcdefgh";
            String numbers = "87654321";
            if ((a > 7)|| (b>7)) return null; //if the number is outside the board, return the default value - null
            else return (Character.toString(letters.charAt(a)) + numbers.charAt(b)); /*charAt - a method with which we extract from the string the element under the passed number, here - under the numbers a and b. Character.toString - a method that converts the received character into a string */
        }

現在讓我們使用以下方法在每個單元格中不僅顯示其顏色，還顯示其數量chessBoardCoord

String [][] chessBoard = new String[8][8];
        for (int i = 0; i < chessBoard.length; i++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                if ((i + j) % 2 == 0) chessBoard[i][j] = "W" + chessBoardCoord(j,i);
                else chessBoard[i][j] = "B"+ chessBoardCoord(j,i);
            }
        }

            for (int i = 0; i < chessBoard.length; i++) {
                for (int j = 0; j < chessBoard[0].length; j++) {
                    System.out.print(" " + chessBoard[i][j] + " ");
                }
                System.out.println();
            }

程序輸出： Wa8 Bb8 Wc8 Bd8 We8 Bf8 Wg8 Bh8 Ba7 Wb7 Bc7 Wd7 Be7 Wf7 Bg7 Wh7 Wa6 Bb6 Wc6 Bd6 We6 Bf6 Wg6 Bh6 Ba5 Wb5 Bc5 Wd5 Be5 Wf5 Bg5 Wh5 Wa4 Bb4 Wc4 Bd4 We4 Bf4 Wg4 Bh4 Ba3 Wb3 Bc3 Wd 3 Be3 Wf3 Bg3 Wh3 Wa2 Bb2 Wc2 Bd2 We2 Bf2 Wg2 Bh2 Ba1 Wb1 Bc1 Wd1 Be1 Wf1 Bg1 Wh1 其中We2表示編號為 e2 的白色方塊。

使用二維數組的範例：矩陣乘法

注意力！此範例需要矩陣的基本知識。這裡對它們的介紹很少，這些資訊是為那些已經研究過但有些忘記了矩陣算術的人準備的。然而，這些知識可以從開源中收集，特別是從維基百科上的文章中收集。這是使用二維數組的一個很好的例子，但是我們可以在沒有它的情況下繼續。因此，如果您現在從數學角度來看似乎難以理解，並且您不想深入研究它，請隨意跳過該示例。如果您學習過基本線性代數，您可能已經了解了矩形數組作為矩形矩陣。 其中 a11、a12...aNN 是一些數字。圖中，矩陣甚至不是矩形，而是正方形（行數等於列數，但情況並非總是如此）。在現實生活中，這樣的矩陣很少遇到，但在程式設計和電腦科學中它們很常見。特別是，它們用於電腦圖形和遊戲引擎。例如，可以使用旋轉矩陣對螢幕上的物件旋轉到任意角度進行程式設計。在二維空間中，旋轉矩陣如下所示： 其中 theta 是物體需要旋轉的角度。相同維度的矩陣可以相互相加，並且相加是逐個元素進行的（我們添加具有相同索引的元素）。但矩陣乘法的運算卻不太熟悉。因此，只有當第一個矩陣的列數與第二個矩陣的行數一致時，才能進行矩陣相乘並獲得結果矩陣。結果矩陣將具有與第一個矩陣相同的行數和與第二個矩陣相同的列數。乘法執行如下。讓我們有一個矩陣a[l][m]和b[m][n]。它們相乘的結果，我們應該得到一個矩陣c[l][n]。要得到c[0][0]乘積矩陣的元素，需要將a[0][0]第一個矩陣的零行的零元素乘以第二個矩陣的零元素，然後將第一個矩陣的第一行的第一個元素乘以第一個元素第二個矩陣的第一列的值，依此類推，然後加入所有所得的乘積。

a[0][0]*b[0][0] + a[0][1]*b[1][0] + … + a[0][m-1]*b[m-1][0]

為了得到結果矩陣第一行的第二個元素，我們對第二行執行相同的過程

a[1][0]*b[0][0] + a[1][1]*b[0][1] + … + a[0][m-1]*b[m-1][0]

依此類推，直到行尾。然後我們轉到下一行並重複該過程，直到我們用完所有行。也就是說，我們將第一個矩陣的行與第二個矩陣的列相乘。下面是矩陣乘法的程式碼。您可以透過檢查是否符合上述行數和列數條件來補充它。

//declaring two matrices
int [][] twoDimArray1 = {{1,0,0,0},{0,1,0,0},{0,0,0,0}};
int[][] twoDimArray2 = {{1,2,3},{1,1,1},{0,0,0},{2,1,0}};

//matrix multiplication process
int[][]twoDimArray3 = new int [twoDimArray1.length][twoDimArray2[0].length];
        for (int i=0; i<twoDimArray3[0].length; i++)
            for (int j=0; j<twoDimArray3.length; j++)
                for (int k=0; k<twoDimArray1[0].length; k++)
                              twoDimArray3[i][j] = twoDimArray3[i][j] + twoDimArray1[i][k] * twoDimArray2[k][j];

//output on display
        for (int i = 0; i < twoDimArray3.length; i++) {
            for (int j = 0; j < twoDimArray3[0].length; j++) {
                System.out.print(" " + twoDimArray3[i][j] + " ");
            }
            System.out.println();
        }

程式輸出以下結果： 1 2 3 1 1 1 0 0 0

非矩形二維數組

由於二維數組是Java中數組的數組，因此每個內部數組可以具有不同的長度。建立陣列時，我們只能指定行數，而不能指定列數（即實際上這些相同行的長度）。讓我們來看一個例子。

//declaring and creating an array, specifying only the number of rows
int [][] twoDimArray = new int[5][];

//initialize the array, filling it with arrays of different lengths
        twoDimArray[0] = new int[]{1, 2, 3, 4, 5};
        twoDimArray[1] = new int[]{1,2,3,4};
        twoDimArray[2] = new int[]{1,2,3};
        twoDimArray[3] = new int[]{1,2};
        twoDimArray[4] = new int[]{1};
//display the resulting non-rectangular two-dimensional array on the screen
        for (int i = 0; i < twoDimArray.length; i++) {
            for (int j = 0; j < twoDimArray[i].length; j++) {
                System.out.print(" " + twoDimArray[i][j] + " ");
            }
            System.out.println();
        }

程式輸出： 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1 因此，陣列的第 0 行包含數組{1,2,3,4,5}，第四行包含數組{1}。

Java中的三維數組

依照常識和Java語言的邏輯，三維數組可以稱為「數組的數組的數組」或「每個元素都是二維數組的數組」。而且，這些二維數組可以不同。例子：

// create a three-dimensional array consisting of two two-dimensional arrays
int[][][] threeDimArr = new int[2][][];
//create the first 2D array of a 5x2 3D array
        threeDimArr[0] = new int[5][2];
//create a second 2D array of a 1x1 3D array
        threeDimArr[1] = new int[1][1];

但在實踐中更常見的是三維數組，其中所有三個量都被同時定義，類似於矩形二維數組。 正如我們已經提到的，三維或更多維的數組很少使用。但是，您可以使用 3D 陣列編寫一些有趣的內容。例如，多層停車場。每個樓層可以被認為是一個二維數組，一個停車位可以被認為是一個三維數組的特定元素。此類陣列的元素可以用類型表示，如果空間空閒，則boolean值為false；如果空間被佔用，則值為 true 。

//set a boolean three-dimensional array. This car park has 3 floors, each of which can accommodate 2x5 = 10 cars. By default, all cells are empty (false)
boolean[][][] parkingLot = new boolean[3][2][5];
//two cars arrived and parked on the ground floor in cell [1][0] and [1][3]
        parkingLot[0][1][0] = true;
        parkingLot[0][1][3] = true;

//Output the array to the console
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 5; k++) {
                    System.out.print("arr[" + i + "][" + j + "][" + k + "] = " + parkingLot[i][j][k] + "\t");

                }
                System.out.println();
            }
        }

二維和三維數組的有趣問題

您對 Java 中的多維數組已經有了足夠的了解，如果您有信心，可以嘗試解決以下一些問題。它們並不容易，但很有趣。井字遊戲。設置一個 3x3 場地，安排兩名輪流球員。最初，該字段是空的，並且在每個空字段中，第一個玩家可以打叉，第二個玩家可以打零。第一個收集到排列成一行、一列或對角線的三個十字或三個零的人獲勝。 蘭頓的螞蟻。有一個特定的字段，分為單元格（二維數組），塗成黑色或白色（可以透過隨機函數設定）。一隻「螞蟻」隨機出現在一個單元格中，每一步它都可以沿著四個方向之一移動到相鄰的單元格，水平或垂直。螞蟻運動規則：

• 在黑色方塊上，螞蟻必須向左轉 90°，將其單元格的顏色變更為白色，然後前進到下一個方塊。
• 在白色方塊上，螞蟻向右旋轉 90°，將其單元格的顏色變為黑色，然後向前走到下一個方塊。

n寫一個方法，在給定螞蟻初始位置的情況下計算步數的迭代。這個欄位可以用零和一隨機填充（或用字母W和表示B，就像我們在棋盤範例中所做的那樣）。我們還需要另外兩個參數 - 螞蟻的水平和垂直位置，以及這一步驟的方向（北、南、西、東），而預設情況下，螞蟻看起來是北。您可以嘗試使用三維數組來建模魔術方塊。標準魔術方塊有 6 個面，每個面都是彩色方塊的三維陣列Color[][][] rubik = new Color[6][3][3]。然而，實作魔術方塊並不是一項簡單的任務。

有關數組的有用資料

JavaRush 上的許多文章都專門討論數組（主要是一維數組，因為它們在實踐中更常用）。注意他們。

1. Java 中的陣列- 初學者的陣列及其範例
2. Something About Arrays - 關於陣列的詳細文章
3. Arrays類別及其使用－文章介紹了該類別的一些方法Array
4. 數組是第一個專門討論數組的 JavaRush 講座。
5. 傳回零長度數組，而不是 null - 《EffectiveProgramming》作者 Joshua Bloch 談論如何更好地返回空數組