Jagged array sa Java

1. Jagged arrays

Bilang isang Java programmer hindi mo lamang maaaring ipagpalit ang mga row ng isang two-dimensional array, ngunit bumuo din ng array gayunpaman ang gusto mo.

Sabihin nating gusto mong ang unang hilera ng isang two-dimensional na array ay may haba na 10, at gusto mong ang haba ng pangalawang hilera ay 50. Kaya ba natin yun? Oo kaya natin.

Una, kailangan nating lumikha ng isang 'lalagyan ng mga lalagyan' — ito ang unang hanay, na mag-iimbak ng mga sanggunian sa mga hanay ng mga hilera. Ito ay kung paano ito ginawa:

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

Aalisin mo lang ang pangalawang dimensyon , at ang Java machine ay gagawa ng 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 ".

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

Sa pamamagitan ng paraan, paano mo mahahanap ang haba ng isang 'lalagyan ng mga lalagyan' sa aming halimbawa? Isa rin itong array object, na nangangahulugang mayroon itong haba. Ang tamang sagot ay matrix.length.

Paano ang tungkol sa mga arrays na bumubuo sa aming mga row?matrix[0].length

2. Paggawa gamit ang isang two-dimensional array

Ipagpalagay na gusto mong magpakita ng dalawang-dimensional na array. Paano mo gagawin iyon?

Magiging ganito ang hitsura ng aming code:

int[][] matrix = new int[3][];
matrix[0] = new int[]{1, 2, 3, 4, 5, 6};
matrix[1] = new int[]{1, 2, 3};
matrix[2] = new int[]{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();
}

Kailangan mo ng dalawang nested na mga loop. Ang una ay tinatawag nating panlabas , at ang pangalawa ay panloob .

Sa panlabas na loop (ang ivariable), sunud-sunod kaming dumaan sa lahat ng mga row (array) na bumubuo sa aming two-dimensional na array. Ang bawat halaga ng iay tumutugma sa isang row na may index na iyon.

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

Ito ang ipapakita:

1 2 3 4 5 6

1 2 3 4 5 6
1 2 3

1 2 3 4 5 6
1 2 3
1

3. Multidimensional na mga array

Isa pang kawili-wiling katotohanan tungkol sa mga array, isa na malamang na nahulaan mo na. Kung maaari kang gumawa ng dalawang-dimensional na array, maaari ka bang gumawa ng tatlong-dimensional na array?

Oo, maaari kang lumikha ng 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];

Masyadong simple ang code na ito, hindi ba?

Paano kung gagawin mo ito nang manu-mano?

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 iyon ay lumilikha lamang ng array! Pagkatapos ay kailangan mo ring magtrabaho kasama ito kahit papaano.

Bonus na gawain: magsulat ng code na nagpapakita ng lahat ng mga halaga sa isang three-dimensional na array.