Multidimensional na mga array

• Mga multidimensional na array, pangkalahatang syntax
• Dalawang-dimensional na array
• Pagdedeklara, paglikha at pagsisimula ng mga two-dimensional na array
• Pagpapakita ng two-dimensional array sa screen
• Mabilis na output ng isang two-dimensional array
• "Mga Haba" ng isang two-dimensional na array
• Halimbawa ng paggamit ng two-dimensional array: checkerboard
• Halimbawa ng paggamit ng two-dimensional array: matrix multiplication
• Non-rectangular two-dimensional arrays
• Mga three-dimensional na array
• Multidimensional arrays sa tunay na gawain ng isang Java programmer
• Mga kawili-wiling problema sa two-dimensional at three-dimensional array

Ano ang isang one-dimensional na Java array?

Ang array ay isang nakaayos na hanay ng mga elemento ng parehong uri, primitive o reference. Ang pangkalahatang impormasyon tungkol sa mga array (karamihan ay one-dimensional) ay makikita sa artikulong “ Arrays in Java ” at sa JavaRush course . Sa artikulong ito ay pag-uusapan natin ang tungkol sa mga array na ang mga elemento ay iba pang mga array. Ang ganitong mga array ay tinatawag na multidimensional. Ang isang array na ang mga elemento ay iba pang mga array, iyon ay, isang array ng mga array, ay tinatawag na two-dimensional. Hindi lahat ng mga wika ay may mga multidimensional array na nakaayos sa ganitong paraan, ngunit sa Java ito ang kaso.

Mga Java Multidimensional Array, Pangkalahatang Syntax

Sa pangkalahatan, ganito ang hitsura ng mga multidimensional array sa Java:

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

Nasaan Data_typeang uri ng mga elemento sa array. Maaaring primitive o sanggunian (klase). Ang bilang ng mga pares ng mga bracket na may dimensionloob ay ang dimensyon ng array (sa aming kaso - N). array_name— pangalan ng array size1...sizN— bilang ng mga elemento sa bawat dimensyon ng array. Pagdedeklara ng mga multidimensional na array:

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

Marahil ang lahat ng ito ay mukhang napaka-abstract, kaya ngayon ay lumipat tayo sa mga kongkretong pagpapakita ng mga multidimensional na array - dalawang-dimensional at tatlong-dimensional. Ang katotohanan ay ang mga developer ng Java kung minsan ay gumagamit ng mga two-dimensional na array, mas madalas - mga three-dimensional, at kahit na mas malalaking array ay napakabihirang. Malaki ang posibilidad na hindi mo sila makaharap.

Ano ang isang two-dimensional na Java array?

Ang isang two-dimensional na array sa Java ay isang array ng mga arrays, ibig sabihin, ang bawat cell ay naglalaman ng reference sa isang array. Ngunit mas madaling ipakita ito sa anyo ng isang talahanayan na may ibinigay na bilang ng mga hilera (unang dimensyon) at bilang ng mga haligi (pangalawang dimensyon). Ang isang dalawang-dimensional na hanay kung saan ang lahat ng mga hilera ay may pantay na bilang ng mga elemento ay tinatawag na hugis-parihaba.

Pagdedeklara, paglikha at pagsisimula ng mga two-dimensional na array

Ang pamamaraan para sa pagdedeklara at paglikha ng dalawang-dimensional na hanay ay halos kapareho ng sa kaso ng isang-dimensional na hanay:

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

Ang array na ito ay may 3 row at 4 na column. Ang laki ng isang hugis-parihaba na two-dimensional array (maaaring hindi sila hugis-parihaba, higit pa sa ibaba), iyon ay, ang kabuuang bilang ng mga elemento ay maaaring matukoy sa pamamagitan ng pag-multiply ng bilang ng mga hilera sa bilang ng mga column. Ito ay pinasimulan na ngayon (napuno) ng mga default na halaga. Ibig sabihin, mga zero. Punan natin ito ng mga halaga na kailangan natin.

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;

Tulad ng mga one-dimensional na array, maaari mong gawin ang pamamaraan ng pagsisimula nang mas mabilis:

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

Sa parehong mga kaso, makakakuha tayo ng dalawang-dimensional na array na may tatlong row at apat na column, na puno ng mga integer.

Pagpapakita ng two-dimensional array sa screen

Ang pinakalohikal na paraan upang gawin ang operasyong ito ay ang unang i-output ang zero line na elemento ayon sa elemento, pagkatapos ay ang pangalawa, at iba pa. Ang pinakakaraniwang paraan upang mag-output ng two-dimensional array sa Java ay ang paggamit ng dalawang nested loops.

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
        }

Mabilis na output ng isang two-dimensional array

Ang pinakamaikling paraan upang magpakita ng listahan ng mga elemento ng isang two-dimensional array sa screen ay ang paggamit ng deepToStringclass method Arrays. Halimbawa:

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

Ang resulta ng programa ay ang sumusunod na output: [[18, 28, 18], [28, 45, 90], [45, 3, 14]]

"Mga Haba" ng isang two-dimensional na array

Upang makuha ang haba ng isang one-dimensional na array (iyon ay, ang bilang ng mga elemento dito), maaari mong gamitin ang variable length. Iyon ay, kung tutukuyin natin ang isang array int a[] = {1,2,3}, pagkatapos ay babalik ang operasyon a.lengthng 3. Ngunit paano kung ilapat natin ang parehong pamamaraan sa ating two-dimensional array?

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

Output: 3 Kaya ang operasyong ito ay naglalabas ng bilang ng mga hilera sa array. Paano makukuha ang bilang ng mga column? Kung tayo ay nakikitungo sa mga hugis-parihaba na dalawang-dimensional na array (iyon ay, ang mga kung saan ang lahat ng mga linya ay magkapareho ang haba), pagkatapos ay maaari nating ilapat ang operasyon twoDimArray[0].lengtho sa halip na ang zero na elemento (esensyal ang zero line) - anumang iba pang umiiral na. Magagawa natin ito dahil sa Java, ang isang two-dimensional na array ay isang array ng mga array, at ang elementong zero twoDimArray[0]ay isang array ng haba 4. Maaari mo itong suriin mismo.

Halimbawa ng paggamit ng two-dimensional array: checkerboard

Maaaring gamitin ang mga two-dimensional array upang lumikha ng anumang may hangganang two-dimensional na field, halimbawa sa mga laro, at partikular sa chess. Madaling isipin ang isang chessboard bilang isang two-dimensional array. Maaari mong "ilakip" ang mga graphics dito, ngunit sa ngayon, tukuyin natin ang isang chessboard gamit ang mga simbolo at i-output ito sa console. Ang ibabang kaliwang parisukat ng chessboard ay pininturahan ng itim, ang susunod ay puti, tulad ng nasa itaas nito. Kaya, nagbabago ang kulay sa tuwing lilipat ka sa isang cell na katabi ng gilid. Upang itakda ang pangkulay ng chess hindi nang manu-mano, ngunit gamit ang isang algorithm, maaari kang gumamit ng parity check: kung ang kabuuan ng row at column index ay pantay o zero, kung gayon ang cell ay magiging puti, kung hindi man ito ay magiging itim. Para sa pagsusuring ito, ginagamit namin ang natitirang operator % sa algorithm. Dahil nagtatrabaho kami hindi gamit ang mga graphics, ngunit may mga simbolo, tutukuyin namin ang puting cell na may titik W(puti), at ang itim na cell na may titik B(itim).

//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";
            }
        }

Ang output ng programa ay ang mga sumusunod: WBWBWBWBBWBWBWBWWBWBW BWBBWBWBWBWWBWBWBWBBW BWBWBWWBWBWBWBWBWBWB W Ang lahat ay parang sa isang tunay na chessboard, maaari mong suriin ito. Ngayon magsulat tayo ng isang paraan para sa tamang pagbilang ng mga cell hindi sa wika ng mga arrays, ngunit sa wikang "chess". Ang ibabang kaliwang cell sa board ay tinatawag na A1, habang sa aming array ito ay chessBoard[7][0]. Iugnay natin ang bawat pares ng mga indeks ng isang two-dimensional array sa kanilang katumbas na "chess". Upang gawin ito, gumagamit kami ng dalawang linya - " abcdefgh" at " 87654321" (sa reverse order - para sa pagiging simple, upang ang checkerboard 8 ay tumutugma sa zero column).

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

Ngayon ipakita natin sa bawat cell hindi lamang ang kulay nito, kundi pati na rin ang numero nito, gamit ang pamamaraanchessBoardCoord

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();
            }

Output ng programa: 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 We Wc4 3 Be3 Wf3 Bg3 Wh3 Wa2 Bb2 Wc2 Bd2 We2 Bf2 Wg2 Bh2 Ba1 Wb1 Bc1 Wd1 Be1 Wf1 Bg1 Wh1 Saan We2ang ibig sabihin ng puting parisukat na may bilang na e2.

Halimbawa ng paggamit ng two-dimensional array: matrix multiplication

Pansin!Ang halimbawang ito ay nangangailangan ng pangunahing kaalaman sa mga matrice. Dito kakaunti ang sasabihin tungkol sa kanila, at ang impormasyong ito ay inilaan para sa mga nag-aral, ngunit medyo nakalimutan, matrix arithmetic. Gayunpaman, ang kaalamang ito ay maaaring makuha mula sa mga bukas na mapagkukunan, lalo na mula sa isang artikulo sa Wikipedia . Ito ay isang magandang halimbawa ng paggamit ng dalawang-dimensional na array, ngunit maaari tayong magpatuloy nang wala ito. Kaya't kung ito ay tila hindi maintindihan sa iyo ngayon mula sa isang matematikal na punto ng view, at hindi mo talaga nais na bungkalin ito, huwag mag-atubiling laktawan ang halimbawa. Kung nag-aral ka ng basic linear algebra, maaaring natutunan mo ang tungkol sa mga rectangular array bilang mga rectangular matrice. Kung saan ang a11, a12... aNN ay ilang numero. Sa figure, ang matrix ay hindi kahit na hugis-parihaba, ngunit parisukat (ang bilang ng mga hilera ay katumbas ng bilang ng mga haligi, ngunit hindi ito palaging nangyayari). Sa totoong buhay, ang mga ganitong matrice ay bihirang makatagpo, ngunit sa programming at computer science ang mga ito ay karaniwan. Sa partikular, ginagamit ang mga ito sa computer graphics at game engine. Halimbawa, ang pag-ikot ng isang bagay sa screen sa anumang anggulo ay maaaring i-program gamit ang rotation matrix. Sa dalawang-dimensional na espasyo, ganito ang hitsura ng rotation matrix: Kung saan ang theta ay ang anggulo kung saan kailangang paikutin ang bagay. Ang mga matrice ng pantay na dimensyon ay maaaring idagdag sa bawat isa, at ang pagdaragdag ay nangyayari sa bawat elemento (nagdaragdag kami ng mga elemento na may parehong mga indeks). Ngunit ang operasyon ng matrix multiplication ay hindi gaanong pamilyar. Kaya, ang mga matrice ay maaaring paramihin at ang isang resultang matrix ay makukuha lamang kung ang bilang ng mga haligi ng unang matrix ay tumutugma sa bilang ng mga hilera ng pangalawa. Ang resultang matrix ay magkakaroon ng parehong bilang ng mga hilera gaya ng una at kaparehong bilang ng mga column gaya ng pangalawa. Ang pagpaparami ay isinasagawa bilang mga sumusunod. Magkaroon tayo ng matrix a[l][m]at b[m][n]. Bilang resulta ng kanilang pagpaparami, dapat tayong kumuha ng matrix c[l][n]. Upang makakuha ng elemento ng c[0][0]isang product matrix, kailangan mong i a[0][0]-multiply ang zero element ng zero row ng unang matrix sa zero element ng pangalawang matrix, pagkatapos ay i-multiply ang unang elemento ng unang row ng unang matrix sa unang elemento ng unang hanay ng pangalawang matrix, at iba pa, pagkatapos ay idinagdag ang lahat ng mga resultang produkto.

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

Upang makuha ang pangalawang elemento ng unang hilera ng resulta matrix, ginagawa namin ang parehong pamamaraan sa pangalawang hilera

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

At iba pa hanggang sa dulo ng linya. Pagkatapos ay lumipat kami sa susunod na linya at ulitin ang pamamaraan hanggang sa maubusan kami ng mga linya. Iyon ay, pinarami namin ang mga hilera ng unang matrix na may mga haligi ng pangalawang matrix. Nasa ibaba ang code para sa matrix multiplication. Maaari mo itong dagdagan ng tseke para sa pagsunod sa nabanggit na kundisyon sa bilang ng mga hilera at column.

//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();
        }

Ang programa ay naglalabas ng sumusunod na resulta: 1 2 3 1 1 1 0 0 0

Non-rectangular two-dimensional arrays

Dahil ang mga two-dimensional na array sa Java ay mga arrays ng mga array, ang bawat isa sa mga panloob na arrays ay maaaring may iba't ibang haba. Kapag gumagawa ng array, maaari lang naming tukuyin ang bilang ng mga row at hindi ang bilang ng mga column (iyon ay, sa katunayan, ang haba ng parehong mga row na ito). Tingnan natin ang isang halimbawa.

//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();
        }

Output ng programa: 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1 Kaya, ang zeroth line ng aming array ay naglalaman ng array {1,2,3,4,5}, at ang ikaapat na linya ay naglalaman ng array {1}.

Mga three-dimensional na array sa Java

Kasunod ng sentido komun at lohika ng wikang Java, ang isang three-dimensional na array ay maaaring tawaging "array ng arrays of arrays" o "isang array na ang bawat elemento ay isang two-dimensional array." Bukod dito, maaaring magkaiba ang dalawang-dimensional na array na ito. Halimbawa:

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

Ngunit mas madalas sa pagsasanay mayroong mga tatlong-dimensional na array kung saan ang lahat ng tatlong dami ay tinukoy nang sabay-sabay, isang analogue ng mga hugis-parihaba na dalawang-dimensional na array. Tulad ng nabanggit na namin, ang tatlong-dimensional o higit pang mga array ay bihirang ginagamit. Gayunpaman, maaari kang mag-program ng isang bagay na kawili-wili gamit ang isang 3D array. Halimbawa, isang multi-storey car park. Ang bawat palapag ay maaaring ituring na isang two-dimensional array, at ang isang parking space ay maaaring ituring na isang partikular na elemento ng isang three-dimensional array. Ang isang elemento ng naturang array ay maaaring katawanin ng isang uri booleanna may value na false kung ang espasyo ay libre at true kung ang espasyo ay inookupahan.

//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();
            }
        }

Mga kawili-wiling problema sa two-dimensional at three-dimensional array

Sapat na ang alam mo tungkol sa mga multidimensional na array sa Java at, kung kumpiyansa ka, maaari mong subukang lutasin ang ilan sa mga problema sa ibaba. Ang mga ito ay hindi madali, ngunit kawili-wili. Tic-tac-toe. Mag-set up ng 3x3 field, gumawa ng dalawang manlalaro na magpalitan. Sa una, ang field ay walang laman, at sa bawat isa sa mga walang laman na field ang unang manlalaro ay maaaring maglagay ng krus, at ang pangalawa ay zero. Ang nagwagi ay ang unang nangongolekta ng tatlong krus o tatlong zero na nakaayos sa isang hilera, isang hanay o pahilis. Langton's Ant . Mayroong isang tiyak na field, nahahati sa mga cell (isang two-dimensional array), pininturahan ng itim o puti (maaaring itakda ng isang random na function). Ang isang "ant" ay random na nabubuhay sa isa sa mga cell, at sa bawat hakbang ay maaari itong lumipat sa isa sa apat na direksyon patungo sa katabing cell, pahalang o patayo. Mga panuntunan sa paggalaw ng langgam:

• Sa isang itim na parisukat, ang langgam ay dapat lumiko 90° pakaliwa, baguhin ang kulay ng cell nito sa puti, pagkatapos ay humakbang pasulong sa susunod na parisukat.
• Sa isang puting parisukat, ang langgam ay lumiliko 90° pakanan at binabago ang kulay ng cell nito sa itim, pagkatapos ay humakbang pasulong sa susunod na parisukat.

Sumulat ng isang paraan na kinakalkula ang pag-ulit sa numero ng hakbang nna ibinigay sa paunang posisyon ng langgam. Ang patlang ay maaaring punan nang random ng mga zero at isa (o tinutukoy ng mga titik Wat B, tulad ng ginawa namin sa halimbawa ng chessboard). Kailangan din natin ng dalawa pang parameter - ang pahalang at patayong posisyon ng langgam, gayundin ang direksyon nito sa hakbang na ito (hilaga, timog, kanluran, silangan), habang sa default ang langgam ay tumitingin sa hilaga. Maaari mong subukang magmodelo ng isang Rubik's cube gamit ang mga three-dimensional array. Ang karaniwang Rubik's cube ay may 6 na mukha, at bawat isa sa kanila ay isang three-dimensional na hanay ng mga may kulay na parisukat Color[][][] rubik = new Color[6][3][3]. Gayunpaman, ang pagpapatupad ng isang Rubik's cube ay hindi isang maliit na gawain.

Mga kapaki-pakinabang na materyales tungkol sa mga array

Maraming mga artikulo sa JavaRush ang nakatuon sa mga array (pangunahin ang mga one-dimensional, dahil mas madalas silang ginagamit sa pagsasanay). Bigyang-pansin sila.

1. Mga Array sa Java - tungkol sa mga array para sa mga nagsisimula na may mga halimbawa
2. Something About Arrays - Magandang detalyadong artikulo sa array
3. Ang klase ng Arrays at ang paggamit nito - inilalarawan ng artikulo ang ilang pamamaraan ng klaseArray
4. Ang Arrays ay ang unang JavaRush lecture na nakatuon sa mga array.
5. Ibalik ang isang zero-length array, hindi null - Ang may-akda ng Effective Programming na si Joshua Bloch ay nagsasalita tungkol sa kung paano mas mahusay na ibalik ang mga walang laman na array