Arrays class, part 2

"Rishi, talagang inaabangan ko ang pag-aaral tungkol sa iba pang pamamaraan ng klase ng Arrays.

"Ang ganitong kasigasigan sa pag-aaral ay hindi makakapagpasaya sa matandang guro mo! Ngunit, kung talagang gusto mong malaman ang lahat, isang mabait na wizard na nagngangalang Google ang tutulong sa iyo araw at gabi."

"Uh..."

"Just kidding. Kind of. Syempre, I'll explain everything better, but if something comes up anything - remember the good wizard. Sisimulan ko ang lesson ngayon gamit ang Arrays.fillmethod .

"Kapag nagtatrabaho sa mga array, ang mga Java programmer ay madalas na kailangang punan ang array na may parehong halaga. Siyempre, maaari kang magsulat ng isang loop at magtalaga ng ilang halaga sa bawat cell ng array sa loop:

int[] x = new int[100];
for (int i = 0; i < x.length; i++)
x[i] = 999;

"O sa halip ng lahat ng ito, maaari mong tawagan ang Arrays.fill()pamamaraan, na eksaktong parehong bagay: pinupunan nito ang naipasa na array ng naipasa na halaga. Narito ang hitsura nito:

Arrays.fill(name, value)

At ang code sa halimbawa sa itaas ay maaaring gawing mas compact at mas malinaw:

int[] x = new int[100];
Arrays.fill(x, 999);

"Ang ganda!"

"Maaari mo ring gamitin ang Arrays.fill()paraan upang punan hindi ang buong array, ngunit isang bahagi nito, na may ilang halaga:

Arrays.fill(name, first, last, value)

"Kung saan ang una at huli ay ang mga indeks ng una at huling mga cell na pupunan.

" Alinsunod sa mabuti (o masamang) lumang tradisyon ng Java, tandaan na ang huling elemento ay hindi kasama sa hanay.

Halimbawa:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

Arrays.fill(x, 3, 7, 999);


String str = Arrays.toString(x);

"Gumagana lang ang Arrays.fill()paraan sa mga one-dimensional na array. Kung magpapasa ka ng two-dimensional array sa method, ituturing itong one-dimensional, kasama ang lahat ng kasunod na mga kahihinatnan.

Arrays.copyOf()

"Amigo, mangyaring sabihin sa akin kung paano baguhin ang laki ng isang array pagkatapos na ito ay malikha?"

"Umm... Iyan ay isang trick na tanong, tama? Hindi na ako gaanong walang karanasan. Ang tamang sagot ay hindi mo magagawa! Hindi mo maaaring baguhin ang laki ng isang array pagkatapos na ito ay malikha."

"Pero paano kung gusto mo talaga?"

"Imposible pa rin!

"Sa totoo lang, kung gusto mo talaga, kaya mo! Sa tulong ng isang programming trick:

1. Una, lumikha ka ng isang bagong hanay ng nais na haba
2. Pagkatapos ay kopyahin mo ang lahat ng mga elemento mula sa unang array papunta dito.

"Ito ang dalawang bagay na Arrays.copyOf()ginagawa ng pamamaraan. Ito ang hitsura ng pagtawag:

Type[] name2 = Arrays.copyOf(name, length);

" Hindi binabago ng paraang ito ang umiiral na array , ngunit sa halip ay gumagawa ng bagong array at kinokopya ang mga elemento ng lumang array dito."

"Paano kung ang haba ng bagong array ay mas mababa sa haba ng dati ?

"Mahusay na tanong, Amigo! Kung ang mga elemento ay hindi magkasya, kung gayon ang mga labis na halaga ay binabalewala lamang."

"At kung, sa kabaligtaran, may mga dagdag na selula, ano ang kanilang mga paunang halaga?

"Kung ang haba ng bagong array ay mas malaki kaysa sa haba ng luma, ang mga cell ay puno ng mga zero.

Halimbawa:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int[] x2 = Arrays.copyOf(x, 5);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOf(x, 15);
String str3 = Arrays.toString(x3);

Arrays.copyOfRange()

"At paano kung gusto mong makakuha ng hanay ng haba 5 mula sa hanay ng haba 10, ngunit kailangan mo itong maglaman ng huling 5 elemento kaysa sa unang 5? Sa kasong ito, kailangan mo ng isa pang paraan ng klase. Ito Arraysay Arrays.copyOfRange(). Ito ang hitsura ng pagtawag dito:

Type[] name2 = Arrays.copyOfRange(name, first, last);

"Ang paraang ito ay lumilikha din ng bagong array, ngunit pinupuno ito ng mga elemento mula sa isang arbitrary na lugar sa orihinal na array. Kung saan ang una at huli ay ang mga indeks ng una at huling elemento na dapat ilagay sa bagong array. Maaari mo bang sabihin sa akin kung ang huling elemento ay kasama sa hanay na ito?"

"Ha! Gaya ng sinasabi ng aking dakilang guro, ' alinsunod sa mabuti (o masamang) lumang tradisyon ng Java, tandaan na ang huling elemento ay hindi kasama sa hanay '."

"Amigo, lumalaki ka sa harapan namin.

Halimbawa:

int[] x = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};

int[] x2 = Arrays.copyOfRange(x, 5, 10);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOfRange(x, 5, 15);
String str3 = Arrays.toString(x3);

Arrays.sort()

"At sa wakas, iniwan ko ang pinaka... mmm... kaaya-ayang paraan para sa huli: pag-uuri . Ang mga array ay madalas na pinagbukud-bukod sa programming. Narito ang nangungunang 3 pinakasikat na pagkilos kapag nagtatrabaho sa mga array:

• Pag-uuri ng array
• Paghahanap ng minimum (o maximum) na elemento ng isang array
• Pagtukoy sa index ng isang elemento sa isang array (paghahanap ng isang elemento sa isang array)

"Ang mahusay na gumaganap na mga algorithm ng pag-uuri, dapat kong sabihin, ay hindi napakadaling isulat. Mas tiyak, ito ay isang karaniwang gawain, at bilang isang mag-aaral, hindi ka makakasama kung magsanay sa pagsusulat ng mga algorithm ng pag-uuri minsan. Ngunit sa trabaho, ito ay mas mabuting huwag mong sayangin ang iyong oras sa muling pag-imbento ng gulong. Isinama ng mga tagalikha ng Java ang sort()pamamaraan sa Arraysklase. Ganito ang hitsura ng pagtawag:

Arrays.sort(name);

Inuuri ng pamamaraang ito ang naipasa na array sa pataas na pagkakasunud-sunod.

Halimbawa:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x);
String str = Arrays.toString(x);

"Magaling! Isang paraan lang ang tinawagan ko at inayos ang array. Isang bagay ng kagandahan!"

"Sa pamamagitan ng paraan, maaari mong pag-uri-uriin hindi lamang ang buong array, kundi pati na rin ang bahagi nito. Ito ang hitsura ng pagtawag dito:

Arrays.sort(name, first, last);

"Kung saan ang una at huli ay ang mga indeks ng una at huling mga cell na dapat hawakan ng pag-uuri. AT...

"Alam ko na kung ano ang sasabihin mo! 'Alinsunod sa mabuti (o masamang) lumang tradisyon ng Java, tandaan na ang huling elemento ay hindi kasama sa hanay' .

Halimbawa:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x, 4, 8);
String str = Arrays.toString(x);

"Upang pag-uri-uriin ang mga array, ginagamit ng Java ang pinakamabilis na algorithm ng pag-uuri — QuickSort . Ang computational complexity nito ay depende sa laki ng array at kinakalkula gamit ang formula N log(N).

"Ang pag-uuri ng isang hanay ng 1000 elemento ay magsasangkot ng humigit-kumulang 10,000 paghahambing ng mga elemento ng array. Ang pag-uuri ng isang hanay ng isang milyong elemento ay magsasangkot ng humigit-kumulang 20 milyong paghahambing."

" Hindi masyadong maraming paghahambing kapag isinasaalang-alang mo ang bilang ng mga elemento!"

"Iyan mismo ang sinasabi ko. Ang QuickSort algorithm ay napakahusay.

Arrays.binarySearch()

"Buweno, at ang pinakahuli sa pinakakawili-wiling mga pamamaraan ng Arraysklase ay nakakapaghanap ng isang ibinigay na halaga sa isang array. Ito ay hindi ordinaryong paghahanap — ito ay ang minamahal na binary na paghahanap . Nagsisimula ito sa:

• Una, ang array ay pinagsunod-sunod.
• Pagkatapos ay ang gitnang elemento ng array ay inihambing sa isa na hinahanap namin.
• Kung mas malaki ang elemento kaysa sa gitnang elemento, magpapatuloy ang paghahanap sa kanang kalahati ng array.
• Kung ang elementong hinahanap namin ay mas mababa sa gitnang elemento, pagkatapos ay magpapatuloy ang paghahanap sa kaliwang kalahati ng array.

"Dahil ang array ay pinagsunod-sunod, posibleng alisin ang kalahati nito sa isang paghahambing. Pagkatapos sa susunod na hakbang, itatapon namin ang isa pang kalahati, at iba pa."

"Fantastic! Mabilis kaming lumipat sa goal!"

"Eksakto. Sa hanay ng isang milyong (!) na elemento, mahahanap ng binary search algorithm ang index ng gustong elemento sa loob lamang ng 20 paghahambing.

Ito ang hitsura ng pagtawag:

int index = Arrays.binarySearch(name, value);

"Nasaan nameang pangalan ng array, na dapat ipasa na pinagsunod-sunod na (halimbawa, gamit ang Arrays.sort()pamamaraan). At valueang elementong hinahanap natin sa array. Ang resulta na ibinalik ng pamamaraan ay ang index ng nais na elemento ng array. .

Mga halimbawa:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};
Arrays.sort(x);

int index1 = Arrays.binarySearch(x, 0);
int index2 = Arrays.binarySearch(x, -20);
int index3 = Arrays.binarySearch(x, 99);
int index4 = Arrays.binarySearch(x, 5);

"Paano kung ang gustong elemento ay lilitaw nang maraming beses sa array ?"

"Iyan ay isang wastong tanong, Amigo. Sa kasong ito, ibabalik ng algorithm ang index ng isa sa kanila (walang garantiya na ito ay, sabihin nating, ang pinakauna, o kabaligtaran — ang pinakahuli sa mga dobleng elementong ito) ."

"Paano kung ang array ay hindi naglalaman ng nais na elemento sa lahat?"

"Sa kasong ito, magbabalik ang algorithm ng negatibong index .

Dokumentasyon

"Malinaw na ang lahat, Rishi! This was very interesting."

"Kung talagang nakita mo itong napaka-interesante, pagkatapos ay sa iyong paglilibang, suriin ang opisyal na dokumentasyon ng Arraysklase at ang mga pamamaraan nito sa website ng Oracle .

"Maaari mong tingnang mabuti, halimbawa, ang Arrays.mismatch()at Arrays.compare()mga pamamaraan. Malamang na magagamit mo ang mga ito sa mabuting paraan.

"At huwag malito sa bilang ng mga pamamaraan. Ang bawat pamamaraan ay may 5-10 variant, na naiiba lamang sa kanilang mga uri ng parameter."