Arrays — isang klase ng katulong

"Amigo, sana sa ngayon ay napagtanto mo na kung gaano kapaki-pakinabang ang mga arrays sa programming?"

"Most definitely, Rishi! Nalutas ko na ang higit sa isang gawain."

"Nagkaroon ba ng paulit-ulit na aksyon ang iyong mga gawain? Yung tipong paulit-ulit mong ginawa."

"Kung naintindihan kita nang tama, ang ibig mong sabihin ay magkatulad na pagkilos sa iba't ibang gawain? Halimbawa, kahit saan gamit ang isang loop upang ipakita ang mga nilalaman ng isang array — pagod na pagod na akong gawin iyon!"

"Oo, iyon ang ibig kong sabihin. Napansin ng mga tagalikha ng Java na ang mga programmer ng Java ay madalas na nagsusulat ng parehong code kapag nagtatrabaho sa mga array. Halimbawa, ang code upang kopyahin ang bahagi ng isang array sa isa pang array, o code upang punan ang bawat cell ng isang array na may parehong halaga. O ang iyong halimbawa: code upang ipakita ang mga nilalaman ng isang array sa isang nababasang anyo sa screen.

"At ang mga tunay na programmer ay may isang napakahalagang panuntunan: huwag ulitin ang iyong sarili. Sasang-ayon ka na mali ang gumawa ng labis na trabaho — hindi ka mababayaran para dito. Ang epektibong trabaho ay mahusay na binabayaran, maniwala ka sa akin. Nagkataon, ang isang baguhan ay Ang code ay agad na nakikilala sa pamamagitan ng malaking halaga ng paulit-ulit na code.

"Pinag-isipan ito ng mga tagalikha ng Java, at nilikha ang espesyal Arraysna klase (ang buong pangalan nito ay java.util.Arrays), na inilalagay ang pinakasikat na mga aksyon na nauugnay sa array."

"Hmm... Very interesting. So ano nga ba ang meron dito?

"Marami itong pamamaraan para sa bawat okasyon, ngunit isasaalang-alang muna natin ang 10 sa mga ito - ang pinakasimple at madalas na ginagamit.

Arrays.toString()

"Ang unang paraan na titingnan natin ay Arrays.toString(). Ngunit una, isang maliit na background.

"Ang bawat array sa Java ay may toString()pamamaraan, na nagbabalik ng 'textual na representasyon ng array'. Maaari kang makakuha ng textual na representasyon ng array gamit ang sumusunod na pahayag:

String str = name.toString();

"Nasaan nameang pangalan ng array variable, at strang pangalan ng variable na mag-iimbak ng string na representasyon ng array. Amigo, nasubukan mo na bang mag-print ng array sa screen gamit ang paraan?System.out.println(name)

Aaminin ko, nangyari iyon. May nakita akong kalokohan. Nagpasya akong lumayo sa paraan ng pinsala at magpatuloy sa paggamit ng mga loop.

"Malamang na nakakita ka ng isang bagay tulad ng:

I@37afeb11

"Ang unang titik Iay nangangahulugan na ito ay isang intarray, at ang mga simbolo pagkatapos @ay ang address ng isang bagay sa memorya. Maaari mong isipin ito bilang address ng array sa memorya. Sa isang banda, ito mismo ang impormasyon na nakaimbak sa array variable, ngunit sa kabilang banda, iba ang inaasahan mo, hindi ba?"

"Eksakto! Pinaplano kong makita ang mga halaga sa array. Ito ang huling bagay na inaasahan ko."

"At iyon mismo ang dahilan kung bakit sila ay gumawa ng Arrays.toString()paraan — upang ipakita ang mga halaga ng isang array. Tinatawag namin itong ganito:

String str = Arrays.toString(name);

Mga halimbawa:

int[] array = {1, 2, 3};
String str = Arrays.toString(array);

int[] array = {};
String str = Arrays.toString(array);

String[] array = {"Hi", "How's", "life?"};
String str = Arrays.toString(array);

Arrays.deepToString()

"Gayunpaman, ang toString()pamamaraan ay hindi sapat pagdating sa dalawang-dimensional na array. Sa madaling salita, kung susubukan mong tumawag Arrays.toString(), makakakita ka ng pamilyar na bagay:

[I@37afeb11, I@37afeb21, I@37afeb31]

"Lahat ito ay dahil ang mga cell ng isang two-dimensional array ay nag-iimbak ng mga sanggunian sa isang-dimensional na array. At paano na-convert ang isang-dimensional na arrays sa isang string? Eksaktong tulad ng nakikita mo sa itaas.

"Ano ang gagawin kung gayon? Paano natin maipapakita nang tama ang isang two-dimensional array?"

"Inaasahan din ito ng mga tagalikha ng Java. Sa layuning ito, ang Arraysklase ay may isa pang espesyal na pamamaraan — deepToString(). Ang pagtawag ay ganito ang hitsura:

String str = Arrays.deepToString(name);

"Ang pamamaraang ito ay maaaring magpasa ng mga array na two-dimensional, one-dimensional, three-dimensional o, sa pangkalahatan, anumang dimensyon, at palaging ipapakita nito ang mga elemento ng array.

Mga halimbawa:

int[] array = {1, 2, 3};
String str = Arrays.deepToString(array);

int[][] array = { {1, 1}, {2, 2}, {3, 3} };
String str = Arrays.deepToString(array);

int[][][] array = { {{1, 2, 3}, {1}}, {{}} };
String str = Arrays.deepToString(array);

Arrays.equals()

"Naisip namin kung paano magpapakita ng mga array sa screen. Paano ang tungkol sa paghahambing ng mga array? Naaalala mo ba kung anong mga pamamaraan ang maaari naming gamitin upang ihambing ang mga string?"

"Karaniwan kong ginagamit ang equalspamamaraan!

"Oo, equals, at gayundin equalsIgnoreCase(na naghahambing ng mga string nang hindi isinasaalang-alang ang uppercase at lowercase).

"Magandang balita: maaari mo ring gamitin ang equalsparaan para sa mga array. Masamang balita: hindi nito inihahambing ang mga nilalaman ng mga array. Ang equalspamamaraan ng mga array ay ginagawa ang parehong bagay tulad ng ==operator — ito ay naghahambing ng mga sanggunian.

Mga halimbawa:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1 == x2;

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

"So ano ang gagawin natin? Paano natin ihahambing ang mga arrays batay sa mga nilalaman nito?"

"Muli ang Arraysklase ay dumating upang iligtas tayo. Mas partikular, ang Arrays.equals()pamamaraan nito. Ganito ang tawag natin dito:

Arrays.equals(name1, name2)

"Ang pamamaraan ay bumabalik truekung ang mga array ay may pantay na haba at ang kanilang mga elemento ay pantay. Kung hindi, ito ay nagbabalik false.

Mga halimbawa:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
Arrays.equals(x1, x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3, 4};
Arrays.equals(x1, x2);

Arrays.deepEquals()

"At, tulad ng malamang na nahulaan mo na, ang Arrays.equalspamamaraan ay hindi gagana nang tama para sa mga two-dimensional na array: tinatrato nito ang dalawang-dimensional na arrays tulad ng isang one-dimensional na array na ang mga elemento ay mga address ng isang-dimensional na array.

"Kaya, upang maihambing nang tama ang mga multidimensional na array ( n = 1, 2, 3,... ), nakaisip sila ng Arrays.deepEquals()pamamaraan. Ang pagtawag dito ay ganito:

Arrays.deepEquals(name1, name2)

"Ang pamamaraan ay bumabalik truekung ang mga array ay may pantay na haba at ang kanilang mga elemento ay pantay. Kung hindi, ito ay babalikfalse. Kung ang mga elemento sa loob ng array ay mga array din, kung gayon ang Arrays.deepEquals()paraan ay ginagamit upang ihambing ang mga ito, at iba pa.

Mga halimbawa:

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};

x1.equals(x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};

Arrays.equals(x1, x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};

Arrays.deepEquals(x1, x2);

"Salamat, Rishi! Ang aral na ito ay ang kailangan ko upang gawing mas madali at mas masaya ang aking buhay sa hinaharap. Ngayon ay gagamitin ko ang mga pamamaraan ng klase ng Arrays at mas mabilis na isusulat ang aking mga programa.

"Iyon ang inaasahan ko, ha-ha. Ngunit hindi ito lahat ng mga kawili-wiling pamamaraan sa klase ng Arrays. Sa susunod na pagkakataon ay sasabihin ko sa iyo ang tungkol sa iba."