อาร์เรย์หลายมิติ

อาร์เรย์ Java หนึ่งมิติคืออะไร?

อาร์เรย์คือชุดองค์ประกอบที่มีการเรียงลำดับประเภทเดียวกัน ทั้งแบบพื้นฐานหรือแบบอ้างอิง ข้อมูลทั่วไปเกี่ยวกับอาร์เรย์ (ส่วนใหญ่เป็นมิติเดียว) สามารถพบได้ในบทความ “ Arrays in 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 ใช้อาร์เรย์สองมิติซึ่งน้อยกว่ามาก - อาร์เรย์สามมิติและแม้แต่อาร์เรย์ที่ใหญ่กว่านั้นก็หายากมาก มีความเป็นไปได้สูงที่คุณจะไม่พบพวกเขา

อาร์เรย์หลายมิติในหลักสูตร JavaRush

ใน JavaRush อาร์เรย์ "ปกติ" จะเริ่มต้นที่ระดับ 7 ของ ภารกิจJava Syntaxและต่อมาในหลักสูตรจะพบมากกว่าหนึ่งครั้ง บางครั้งตลอดหลักสูตรคุณจะพบปัญหาเกี่ยวกับอาร์เรย์สองมิติ (หรือปัญหาที่สามารถแก้ไขได้ด้วยความช่วยเหลือ) อาร์เรย์สองมิติยังใช้ในเอ็นจิ้นเกมของส่วนพิเศษ " เกมบน JavaRush " หากคุณยังไม่เคยไป ลองดูและสร้างเกมสักหนึ่งหรือสองเกม ข้อกำหนดและเงื่อนไขมาพร้อมกับคำแนะนำโดยละเอียด และจะให้การฝึกอบรมทักษะการเขียนโปรแกรมที่ยอดเยี่ยม อาร์เรย์สามมิติสามารถพบได้ในเกมSpace Invaders โดยมีการระบุชุดของเฟรมสำหรับภาพเคลื่อนไหว (และแต่ละเฟรมเหล่านี้เป็นอาร์เรย์สองมิติ) หากคุณทำภารกิจ JavaSyntax สำเร็จแล้วหรือเพียงแค่รู้สึกมั่นใจในการเขียนโปรแกรม 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}};

ในทั้งสองกรณี เราจะได้อาร์เรย์สองมิติที่มีสามแถวและสี่คอลัมน์ ซึ่งเต็มไปด้วยจำนวนเต็ม อาร์เรย์หลายมิติ - 2

การแสดงอาร์เรย์สองมิติบนหน้าจอ

วิธีที่สมเหตุสมผลที่สุดในการดำเนินการนี้คือการส่งออกองค์ประกอบเส้นศูนย์ก่อนตามองค์ประกอบ จากนั้นครั้งที่สอง และต่อไปเรื่อยๆ วิธีทั่วไปที่สุดในการส่งออกอาเรย์สองมิติใน 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].lengthหรือแทนที่องค์ประกอบศูนย์ (โดยพื้นฐานแล้วคือเส้นศูนย์) - องค์ประกอบอื่นที่มีอยู่ เราสามารถทำได้เพราะใน Java อาร์เรย์สองมิติคืออาร์เรย์ของอาร์เรย์ และองค์ประกอบศูนย์twoDimArray[0]คืออาร์เรย์ที่มีความยาว 4 คุณสามารถตรวจสอบได้ด้วยตัวเอง

ตัวอย่างการใช้อาร์เรย์สองมิติ: กระดานหมากรุก

อาร์เรย์สองมิติสามารถใช้เพื่อสร้างฟิลด์สองมิติที่มีขอบเขตจำกัดได้ เช่น ในเกม และโดยเฉพาะอย่างยิ่งในหมากรุก เป็นเรื่องง่ายที่จะคิดว่ากระดานหมากรุกเป็นอาร์เรย์สองมิติ คุณสามารถ “แนบ” กราฟิกเข้ากับสิ่งนี้ได้ แต่สำหรับตอนนี้ เรามากำหนดกระดานหมากรุกโดยใช้สัญลักษณ์แล้วส่งออกไปยังคอนโซลกันดีกว่า อาร์เรย์หลายมิติ - 3

สี่เหลี่ยมด้านซ้ายล่างของกระดานหมากรุกทาสีดำ ส่วนถัดไปเป็นสีขาว เช่นเดียวกับด้านบน ดังนั้นสีจะเปลี่ยนไปทุกครั้งที่คุณย้ายไปยังเซลล์ที่อยู่ติดกับด้านข้าง หากต้องการตั้งค่าการระบายสีหมากรุกด้วยตนเอง แต่ใช้อัลกอริทึมคุณสามารถใช้การตรวจสอบความเท่าเทียมกัน: หากผลรวมของดัชนีแถวและคอลัมน์เป็นเลขคู่หรือศูนย์เซลล์จะเป็นสีขาวมิฉะนั้นจะเป็นสีดำ สำหรับการตรวจสอบนี้ เราใช้ตัวดำเนินการส่วนที่เหลือ % ในอัลกอริทึม เนื่องจากเราไม่ได้ทำงานกับกราฟิก แต่ใช้สัญลักษณ์ เราจะแสดงเซลล์สีขาวด้วยตัวอักษร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 BWBWBWWBWBWBWBBWBWBWB W ทุกอย่างเหมือนบนกระดานหมากรุกจริงคุณสามารถตรวจสอบได้ อาร์เรย์หลายมิติ - 4

ตอนนี้เรามาเขียนวิธีการกำหนดหมายเลขเซลล์ให้ถูกต้องไม่ใช่ในภาษาอาเรย์ แต่เป็นภาษา "หมากรุก" เซลล์ซ้ายล่างบนกระดานเรียกว่า 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 บี3 Wf3 Bg3 Wh3 Wa2 Bb2 Wc2 Bd2 We2 Bf2 Wg2 Bh2 Ba1 Wb1 Bc1 Wd1 Be1 Wf1 Bg1 Wh1 โดยที่We2หมายถึงสี่เหลี่ยมสีขาวที่มีหมายเลข e2

ตัวอย่างการใช้อาร์เรย์สองมิติ: การคูณเมทริกซ์

ความสนใจ!ตัวอย่างนี้ต้องการความรู้พื้นฐานเกี่ยวกับเมทริกซ์ จะมีการพูดถึงพวกเขาน้อยมากที่นี่ และข้อมูลนี้มีไว้สำหรับผู้ที่ศึกษาเลขคณิตเมทริกซ์ แต่ค่อนข้างลืมไปแล้ว อย่างไรก็ตาม ความ รู้นี้สามารถรวบรวมได้จากโอเพ่นซอร์ส โดยเฉพาะจากบทความใน Wikipedia นี่เป็นตัวอย่างที่ดีของการใช้อาร์เรย์สองมิติ แต่เราสามารถไปต่อได้โดยไม่ต้องใช้อาร์เรย์ ดังนั้น หากตอนนี้ดูเหมือนว่าคุณไม่สามารถเข้าใจได้สำหรับคุณจากมุมมองทางคณิตศาสตร์ และคุณไม่ต้องการเจาะลึกมันจริงๆ อย่าลังเลที่จะข้ามตัวอย่างไปได้เลย หากคุณเคยศึกษาพีชคณิตเชิงเส้นขั้นพื้นฐาน คุณอาจได้เรียนรู้เกี่ยวกับอาร์เรย์สี่เหลี่ยมเป็นเมทริกซ์สี่เหลี่ยม อาร์เรย์หลายมิติ - 5

โดยที่ a11, a12... anNN คือตัวเลขบางตัว ในรูปเมทริกซ์ไม่ได้เป็นรูปสี่เหลี่ยมผืนผ้า แต่เป็นสี่เหลี่ยมจัตุรัส (จำนวนแถวเท่ากับจำนวนคอลัมน์ แต่ก็ไม่ได้เป็นเช่นนั้นเสมอไป) ในชีวิตจริงเมทริกซ์ดังกล่าวไม่ค่อยพบเห็น แต่ในการเขียนโปรแกรมและวิทยาการคอมพิวเตอร์มันเป็นเรื่องธรรมดามาก โดยเฉพาะอย่างยิ่งใช้ในคอมพิวเตอร์กราฟิกและเอ็นจิ้นเกม ตัวอย่างเช่น การหมุนของวัตถุบนหน้าจอไปยังมุมใดก็ได้สามารถตั้งโปรแกรมได้โดยใช้เมทริกซ์การหมุน ในปริภูมิสองมิติ เมทริกซ์การหมุนจะมีลักษณะดังนี้ โดย อาร์เรย์หลายมิติ - 6

ที่ทีต้าคือมุมที่วัตถุจะต้องหมุน คุณสามารถเพิ่มเมทริกซ์ที่มีขนาดเท่ากันเข้าด้วยกันได้ และการบวกจะเกิดขึ้นทีละองค์ประกอบ (เราเพิ่มองค์ประกอบที่มีดัชนีเดียวกัน) แต่การดำเนินการของการคูณเมทริกซ์ไม่ค่อยคุ้นเคย ดังนั้นจึงสามารถคูณเมทริกซ์ได้และจะได้เมทริกซ์ผลลัพธ์ได้ก็ต่อเมื่อจำนวนคอลัมน์ของเมทริกซ์แรกตรงกับจำนวนแถวของคอลัมน์ที่สอง เมทริกซ์ผลลัพธ์จะมีจำนวนแถวเท่ากันกับแถวแรกและจำนวนคอลัมน์เท่ากันกับแถวที่สอง การคูณทำได้ดังนี้ ขอให้ เรามีเมทริกซ์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 ดังนั้น บรรทัดที่ศูนย์ของอาเรย์ของเราจึงประกอบด้วยอาเรย์{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];

แต่ในทางปฏิบัติมักมีอาร์เรย์สามมิติซึ่งมีการกำหนดปริมาณทั้งสามในคราวเดียว ซึ่งเป็นอะนาล็อกของอาร์เรย์สองมิติรูปสี่เหลี่ยมผืนผ้า อาร์เรย์หลายมิติ - 7

ดังที่เราได้กล่าวไปแล้ว มีการใช้อาร์เรย์สามมิติหรือมากกว่านั้นน้อยมาก อย่างไรก็ตาม คุณสามารถเขียนโปรแกรมสิ่งที่น่าสนใจด้วยอาเรย์ 3 มิติได้ เช่น ที่จอดรถหลายชั้น แต่ละชั้นถือได้ว่าเป็นอาร์เรย์สองมิติ และพื้นที่จอดรถถือได้ว่าเป็นองค์ประกอบเฉพาะของอาร์เรย์สามมิติ องค์ประกอบของอาร์เรย์ดังกล่าวสามารถแสดงด้วยประเภทbooleanที่มีค่าเป็นเท็จหากพื้นที่ว่างและเป็นจริงหากพื้นที่นั้นถูกครอบครอง

//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

ในความเป็นจริง นักพัฒนา Java ส่วนใหญ่ไม่พบอาร์เรย์หลายมิติบ่อยนัก อย่างไรก็ตาม มีงานจำนวนหนึ่งที่เหมาะกับโครงสร้างข้อมูลนี้เป็นอย่างยิ่ง

สำหรับการทดสอบและการตั้งค่าเมทริกซ์เป็นค่าคงที่เพื่อตรวจสอบอัลกอริทึมเฉพาะ
บางครั้งอาร์เรย์หลายมิติถูกใช้สำหรับโครงข่ายประสาทเทียม
อาร์เรย์หลายมิติเหมาะสำหรับผู้จัดเก็บ
การทำงานกับรูปภาพ

ปัญหาที่น่าสนใจเกี่ยวกับอาร์เรย์สองมิติและสามมิติ

คุณมีความรู้เกี่ยวกับอาร์เรย์หลายมิติใน Java เพียงพอแล้ว และหากคุณรู้สึกมั่นใจ คุณสามารถลองแก้ไขปัญหาด้านล่างนี้ได้ ไม่ใช่เรื่องง่าย แต่น่าสนใจ ทิกแทคโท จัดทำสนามขนาด 3x3 สร้างผู้เล่นสองคนผลัดกัน เริ่มแรกสนามจะว่างเปล่า และในแต่ละสนามว่างผู้เล่นคนแรกสามารถวางกากบาทได้ และสนามที่สองเป็นศูนย์ ผู้ชนะคือผู้ที่รวบรวมไม้กางเขนสามอันหรือศูนย์สามตัวก่อนโดยจัดเรียงในแถวเดียว หนึ่งคอลัมน์ หรือแนวทแยง

อ่านอะไรอีก.
เกม Java สำหรับผู้เริ่มต้น

มดของแลงตัน มีฟิลด์บางฟิลด์แบ่งออกเป็นเซลล์ (อาร์เรย์สองมิติ) ทาสีดำหรือสีขาว (สามารถตั้งค่าได้ด้วยฟังก์ชันสุ่ม) “มด” สุ่มปรากฏขึ้นมาในเซลล์ใดเซลล์หนึ่ง และในแต่ละขั้นตอน มดสามารถเคลื่อนที่ไปในทิศทางใดทิศทางหนึ่งในสี่ทิศทางไปยังเซลล์ที่อยู่ติดกัน ในแนวนอนหรือแนวตั้ง กฎการเคลื่อนไหวของมด:

บนสี่เหลี่ยมสีดำ มดจะต้องหมุนไปทางซ้าย 90° เปลี่ยนสีของเซลล์เป็นสีขาว จากนั้นก้าวไปข้างหน้าไปยังสี่เหลี่ยมถัดไป
บนสี่เหลี่ยมสีขาว มดจะหมุนไปทางขวา 90° และเปลี่ยนสีของเซลล์เป็นสีดำ จากนั้นก้าวไปข้างหน้าไปยังสี่เหลี่ยมถัดไป

เขียนวิธีการคำนวณการวนซ้ำตามหมายเลขขั้นตอนnโดยพิจารณาจากตำแหน่งเริ่มต้นของมด ช่องสามารถเติมเลขศูนย์และเลขแบบสุ่มลงในฟิลด์ได้ (หรือแสดงด้วยตัวอักษรWและBดังที่เราทำในตัวอย่างกระดานหมากรุก) นอกจากนี้เรายังต้องการพารามิเตอร์อีกสองตัว ได้แก่ ตำแหน่งแนวนอนและแนวตั้งของมด รวมถึงทิศทางในขั้นตอนนี้ (เหนือ ใต้ ตะวันตก ตะวันออก) โดยค่าเริ่มต้นมดจะมองไปทางทิศเหนือ คุณสามารถลองสร้างโมเดลลูกบาศก์รูบิคโดยใช้อาร์เรย์สามมิติ Color[][][] rubik = new Color[6][3][3]ลูกบาศก์รูบิ กมาตรฐานมี 6 หน้า และแต่ละหน้าเป็นสี่เหลี่ยมสีเรียงกันสามมิติ อย่างไรก็ตาม การใช้ลูกบาศก์รูบิคไม่ใช่เรื่องเล็กน้อย

เนื้อหาที่เป็นประโยชน์เกี่ยวกับอาร์เรย์

บทความจำนวนมากเกี่ยวกับ JavaRush เน้นไปที่อาร์เรย์ (ส่วนใหญ่เป็นบทความมิติเดียว เนื่องจากมักใช้ในทางปฏิบัติมากกว่ามาก) ให้ความสนใจกับพวกเขา

อาร์เรย์ใน Java - เกี่ยวกับอาร์เรย์สำหรับผู้เริ่มต้นด้วยตัวอย่าง
บางอย่างเกี่ยวกับอาร์เรย์ - บทความที่มีรายละเอียดดีเกี่ยวกับอาร์เรย์
คลาส Arrays และการใช้งาน - บทความนี้จะอธิบายวิธีการบางอย่างของคลาสArray
Arrays เป็นการบรรยาย JavaRush ครั้งแรกที่เน้นเรื่องอาร์เรย์โดยเฉพาะ
ส่งคืนอาร์เรย์ที่มีความยาวเป็นศูนย์ ไม่ใช่ null - ผู้เขียนการเขียนโปรแกรมที่มีประสิทธิภาพ Joshua Bloch พูดถึงวิธีส่งคืนอาร์เรย์ว่างได้ดีขึ้น