Jagged arrays sa Java

"Hello, ang pinakamatalino kong estudyante!"

"Hello, Rishi!"

"Naghahangad ka ba ng bagong talakayan tungkol sa mga array? Well, ngayon mayroon kaming isa para sa iyo! Ngayon ay sasabihin ko sa iyo ang tungkol sa mga tulis-tulis at multidimensional na array."

"Mukhang uhaw sa dugo at nakakatakot."

"Huwag mag-alala, ang isang tunay na programmer ay palaging makakahawak ng isang array, kahit na ito ay hubad ang kanyang mga ngipin. Bukod sa biro, ang jaggedness ng isang array ay sumasalamin sa kakayahang hindi lamang upang palitan ang mga hilera ng isang two-dimensional array, ngunit din upang bumuo ng isang array gayunpaman ito ay kailangang maging.

"Sabihin nating gusto mong ang unang hilera ng isang two-dimensional array ay may haba na 10, at ang pangalawa ay 50."

"Kaya mo ba talaga?"

"Talaga! Una, gumawa kami ng 'lalagyan ng mga lalagyan' — ito ang unang array, na mag-iimbak ng mga sanggunian sa mga hanay ng mga hilera. Ganito ito ginagawa:

int[][] name = new int[height][];

"Aalisin mo lang ang pangalawang dimensyon , at ang Java machine ay lumilikha ng isang lalagyan ng mga lalagyan. Ito ang magiging memorya pagkatapos isagawa ang code na ito:

"At, well, alam mo na kung paano gumawa ng mga one-dimensional na array 🙂

Ito ang magiging hitsura ng resultang code:

// Matrix of important data
int[][] matrix = new int[2][];
matrix[0] = new int[10];
matrix[1] = new int[50]

"Kakagawa lang namin ng tinatawag na " jagged" array. Ang mga gilid nito ay magaspang at hindi regular.

"At kung gusto na nating ipakita ang lahat ng elemento ng array na ito sa screen, lengthmagiging kapaki-pakinabang ang array ng array: pagkatapos ng lahat, iba ang haba ng mga row ng array.

"Nga pala, maaari mo bang sabihin sa akin kung paano hanapin ang haba ng isang 'lalagyan ng mga lalagyan' sa aming halimbawa? Isa rin itong array object, na nangangahulugan na mayroon itong haba."

"Malamang matrix.length?"

"Tama! At para sa mga arrays na bumubuo sa mga row, gagamitin namin matrix[0].lengthpara sa zeroth row."

"At para sa una, ibig sabihin ay gagamitin natin matrix[1].length?"

"Tama. Sa unang kaso, ang pagpapatupad ng command ay magbubunga ng 10, at sa pangalawang kaso, ang resulta ay 50.

Paggawa gamit ang isang two-dimensional array

"Ngayon, subukan nating magpakita ng two-dimensional array:

int[][] matrix = new int[3][];
matrix[0] = {1, 2, 3, 4, 5, 6};
matrix[1] = {1, 2, 3};
matrix[2] = {1};
for (int i = 0; i < matrix.length; i++)
{
   for (int j = 0; j < matrix[i].length; j++)
      System.out.print( matrix[i][j] + " " );
   System.out.println();
}

"Tulad ng nakikita mo, kailangan namin ng dalawang nested loop. Ang una ay tinatawag naming panlabas, at ang pangalawa - panloob .

"Sa outer loop (ang ivariable), sunud-sunod naming dinadaanan ang lahat ng row (arrays) na bumubuo sa aming two-dimensional array. Ang bawat value ng ay itumutugma sa isang row na may index na iyon.

"Sa inner loop (ang jvariable), inuulit namin ang lahat ng mga cell sa mga row. Salamat sa inner loop, isang row, na binubuo ng mga value ng isang one-dimensional array, ay ipapakita sa screen.

"Ito ang ipapakita:

Multidimensional na mga array

"Amigo! Nahulaan mo ba na kung mayroong dalawang-dimensional na mga array, kung gayon maaari ding mayroong mga three-dimensional?

"Iniisip ko lang yun, pero nahihiya akong magtanong.

"Oo, maaari kang lumikha ng isang three-dimensional na array, at sa pangkalahatan, isang array ng anumang dimensyon. Ang ganitong mga array ay tinatawag na 'multidimensional'. Para lang masaya, gumawa tayo ng multidimensional array na may 4 na dimensyon.

 int[][][][] matrix = new int[2][3][4][5];

"Mukhang hindi napakahirap!"

"Hindi mo pa nasusubukang gumawa ng isa nang manu-mano! Dito, pagmasdan mo ito:

int[][][][] matrix;
matrix = new int[2][][][];                   // Create a 2-element array of references to references to references
for (int i = 0; i < matrix.length; i++)
{
  matrix[i] = new int[3][][];                // Create a 3-element array of references to references
  for (j = 0; j < matrix[i].length; j++)
  {
    matrix[i][j] = new int[4][];             // Create a 4-element array of references
    for (k = 0; k < matrix[i][j].length; k++)
      matrix[i][j][k] = new int[5];          // Create 5-element arrays of integers
  }
}

"At gumagawa lang iyon ng array! Pagkatapos ay kailangan mo rin itong gawin kahit papaano."

"Binabawi ko ang sinabi ko. It's not so easy to work with them. But it is possible."

"Dahil posible, narito ang isang bonus na gawain. Sumulat ng code na nagpapakita ng lahat ng mga halaga sa isang three-dimensional na array. Alam mo na sapat na upang gawin ito. Ang pangunahing bagay ay maging matiyaga at matulungin. O maaaring maging maparaan (mayroong isang lihim na kaunti ng kaalaman na tutulong sa iyo na malutas ang gawaing ito sa isang linya). Ngunit kahit paano mo ito lutasin, lutasin ito."

"Salamat, Rishi. Susubukan ko."