Arrays class, part 2

1.Arrays.fill()

Kapag nagtatrabaho sa mga array, ang mga programmer ng Java ay madalas na kailangang punan ang array na may parehong halaga. Maaari kang, siyempre, magsulat ng isang loop at magtalaga lamang 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 maaari mo lamang tawagan ang Arrays.fill()pamamaraan, na gumagawa ng eksaktong parehong bagay: pinupuno nito ang naipasa na hanay 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);

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.

Halimbawa:

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

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


String str = Arrays.toString(x);

"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

Arrays.fill()Gumagana lamang ang pamamaraan sa mga one-dimensional na array. Kung ipapasa mo ang isang two-dimensional array sa pamamaraan, ito ay ituturing bilang one-dimensional, kasama ang lahat ng kasunod na mga kahihinatnan.

2.Arrays.copyOf()

Tulad ng alam mo na, hindi mo maaaring baguhin ang laki ng isang array pagkatapos itong malikha.

Pero paano kung gusto mo talaga?

Well, kung gusto mo talaga, kaya mo!

• Gumawa ng bagong array ng gustong haba
• Kopyahin ang lahat ng mga elemento mula sa unang array papunta dito.

Sa pamamagitan ng paraan, ito mismo ang 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.

Kung ang mga elemento ay hindi magkasya (ang haba ay mas mababa kaysa sa haba ng umiiral na array ), kung gayon ang mga karagdagang halaga ay hindi papansinin.

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

"[1, 2, 3, 4, 5]"

"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0]"

3.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, isa pang paraan ng Arraysklase ang magiging kapaki-pakinabang - ang Arrays.copyOfRange(). Narito kung ano ang hitsura kapag tinawag namin ito:

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

Lumilikha din ang paraang ito 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.

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

"[16, 17, 18, 19, 20]"

"[16, 17, 18, 19, 20, 0, 0, 0, 0, 0]"

4.Arrays.sort()

Ah, ang pinaka masarap na treat: pag-uuri . Ang mga array ay madalas na pinagsunod-sunod sa programming. Ang tatlong pinakakaraniwang pagkilos kapag nagtatrabaho sa mga array ay:

• 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)

Ito ang eksaktong dahilan kung bakit isinama ng mga tagalikha ng Java ang sort()pamamaraan sa Arraysklase. Ito 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);

"[-20, -20, -20, -2, 0, 3, 8, 11, 99, 999]"

Napakahusay, tama? Tumawag ka ng isang paraan, at ngayon ay mayroon kang pinagsunod-sunod na hanay. Maganda.

Sa pamamagitan ng paraan, maaari mong gamitin ang paraang ito upang pag-uri-uriin hindi lamang ang buong array, ngunit bahagi lamang nito. Ito ang hitsura ng pagtawag:

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.

Halimbawa:

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

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

"[11, -2, 3, 0, -20, -20, 8, 999, 99, -20]"

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 3,000 paghahambing ng mga elemento ng array. Ang pag-uuri ng isang hanay ng isang milyong elemento ay magsasangkot ng humigit-kumulang 6 na milyong paghahambing.

5.Arrays.binarySearch()

Well, at ang pinakahuli sa mga pinaka-kagiliw-giliw na pamamaraan ng Arraysklase ay magagawang maghanap para sa isang naibigay na halaga sa isang array. Hindi ito ordinaryong paghahanap — ito ang minamahal na binary search . Ito ay bumagsak dito:

• 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 natin ay mas mababa kaysa sa gitnang elemento, ang paghahanap ay magpapatuloy sa kaliwang kalahati ng array.

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

Ang diskarteng ito ay ginagawang napakabilis ng paghahanap ng binary. Sa hanay ng isang milyong (!) na elemento, mahahanap nito ang index ng gustong elemento sa 20 paghahambing lamang. Ang pagkukulang ng diskarte ay ang array ay dapat munang ayusin, at ang pag-uuri ay nangangailangan din ng oras.

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

{-20, -20, -20, -2, 0, 3, 8, 11, 99, 999}

Kung ang array ay naglalaman ng maraming instance ng elementong hinahanap, ibabalik lang ng algorithm ang index ng isa sa mga ito (walang garantiya na ito ay, sabihin nating, ang pinakauna, o vice versa — ang pinakahuli sa mga ito. mga dobleng elemento)."

Kung ang elemento ay hindi matatagpuan sa array, ang index ay magiging negatibo.

6. Mag-link sa dokumentasyon ng Oracle sa Arraysklase

Kung sobrang interesado ka, mababasa mo ang lahat tungkol sa Arraysklase at lahat ng pamamaraan nito sa opisyal na dokumentasyon a href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base /java/util/Arrays.html">sa website ng Oracle.

Halimbawa, maaari mong basahin ang tungkol sa Arrays.mismatch()at Arrays.compare()mga pamamaraan. Marahil ay makikita mong kapaki-pakinabang ang mga ito kahit papaano.

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.