Arrays class at ang paggamit nito

Hello ulit! :) Sa huling aralin, nakilala namin ang gayong istraktura ng data bilang isang array (Java array), natutunan kung paano lumikha ng mga array, punan ang mga ito ng data, at natutunan din kung paano sila nakaimbak sa memorya. Ngayon ay titingnan natin ang ilang mga gawain at mga halimbawa ng pagtatrabaho sa mga array na madalas mong makaharap sa totoong trabaho. Halimbawa, isipin ang sitwasyong ito: mayroon kaming hanay ng 10 numero na nakasulat sa random na pagkakasunud-sunod.

//array Java, example
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

Ang aming gawain ay pag-uri-uriin ang array na ito sa pataas na pagkakasunud-sunod: mula sa pinakamaliit hanggang sa pinakamalalaking numero. Sa huli dapat itong magmukhang ganito:

[-234, -2, 16, 26, 35, 43, 80, 92, 99, 167]

Paano natin ito gagawin? Ang gawain ay hindi mahalaga, hindi pa namin nagawa ito dati :/ Any ideas? Hulaan mo. Narito ang maaari nating gawin, halimbawa:

• Ulitin ang lahat ng elemento ng array. Ihambing ang bawat elemento sa susunod ( [0]may [1], [1]may [2], [2]may , [3]atbp.). Kung ang kasalukuyang elemento ng array ay mas malaki kaysa sa susunod, pinapalitan namin ang mga ito at lumipat sa susunod na elemento. Kung hindi, iwanan ito at magpatuloy.


• Kaya, pagkatapos ng unang pagpasa sa mga elemento ng array, ang pinakamalaking halaga (167) ay ginagarantiyahan na nasa huling cell.


• Ngayon ay balikan natin ang lahat ng mga elemento ng array, simula sa elemento na may index [0], ngunit hanggang sa penultimate elemento (ang pinakamalaking bilang ay nasa lugar nito) at gawin ang parehong mga paghahambing at pagpapalit. 
  Sa dulo, sa penultimate cell magkakaroon tayo ng pangalawang pinakamataas na halaga (99).


• Ulitin natin ang gawaing ito nang maraming beses hangga't mayroon tayong minus isang elemento sa array.

Nakaisip kami ng ideya, ang natitira na lang ay isulat ang code. Magiging ganito ang hitsura:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       for (int i = numbers.length - 1; i > 0; i--) {
           for (int j = 0; j < i; j++) {
           /* Compare the elements in pairs,
             if they are in the wrong order,
             then swap them */
               if (numbers[j] > numbers[j + 1]) {
                   int tmp = numbers[j];
                   numbers[j] = numbers[j + 1];
                   numbers[j + 1] = tmp;
               }
           }
       }

   }
}

Um... Mukhang medyo kumplikado -_- Kahit na ang pangkalahatang prinsipyo ng operasyon ay malinaw, kailangan mong magsulat ng napakaraming code upang malutas ang isang tila simpleng gawain. Okay, baka naman masyado lang nating tinantiya ang sarili natin? Malamang, napakahirap para sa atin ng gawaing tinanggap natin sa ngayon. Subukan nating gumawa ng mas simple. Halimbawa, kunin natin ang parehong hanay ng mga numero.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

Ang aming gawain ay kopyahin ang mga nilalaman nito sa isa pang array.

int [] numbersCopy = new int[10];

Isipin kung paano mo ito gagawin gamit ang kaalaman tungkol sa mga arrays na mayroon ka na? Maaari mong, halimbawa, mag-loop sa isang array numbersat isulat ang mga elemento nito nang paisa-isa sa numbersCopy:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = new int[10];

       for (int i = 0; i < numbers.length; i++) {

           numbersCopy[i] = numbers[i];
       }

   }
}

Well, mas marami o mas kaunti pa ang nagawa namin! Ang problema ay tila nalutas, ngunit muli: kung kailangan itong maisakatuparan nang madalas, ang code ay magkakaroon ng isang bungkos ng magkaparehong mga loop. Sa katunayan, ang mga ito at iba pang mga problema ay matagal nang nalutas ng mga tagalikha ng Java, at hindi namin kailangang "muling baguhin ang gulong" at magsulat ng ilang code para sa aming sariling solusyon.

klase ng Java Arrays

Tutulungan ka ng isang espesyal na klase ng Java na malutas ang mga karaniwang problema kapag nagtatrabaho sa mga array - Arrays. Ang mga pamamaraan ay idinagdag sa klase na ito upang malutas ang mga pinakakaraniwang problema na kinakaharap ng mga programmer ng Java sa kanilang trabaho. Halimbawa, ang gawain ng pag-uuri ng isang array, kung saan sinubukan namin mismo na magkaroon ng mga solusyon, ay maaaring malutas sa isang linya:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       Arrays.sort(numbers);

       System.out.println(Arrays.toString(numbers));

   }
}

Ang pamamaraan Arrays.sort()ay nag-uuri ng array. Bukod dito, ang algorithm na naka-embed dito ay ginagawang mas mahusay kaysa sa code na isinulat namin. Output ng console:

[-234, -2, 16, 26, 35, 43, 80, 92, 99, 167]

Pakitandaan: upang i-convert ang array sa isang string, gumamit kami ng isa pang paraan ng klase Arrays- Arrays.toString(). Ang mga array ng Java mismo ay hindi nag-override sa toString(). Kaya kung magsusulat ka lang

System.out.println(numbers.toString());

toString()ang paraan ng klase ay tatawagin Object. Sa kaso ng mga arrays, ang output ay magiging ganito:

[I@4554617c

Ngayon ay hindi na tayo magdetalye tungkol sa kung bakit ganito ang konklusyon; ang pangunahing bagay ay malinaw na hindi ito ang kailangan natin. Ngunit ginawa ng Arrays.toString() ang gusto namin. Sa pamamagitan ng paraan, ang aming problema sa pagkopya ay madaling malutas sa klase Arrays:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, numbers.length);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Sa paraang Arrays.copyOf()ipinapasa namin ang aming orihinal na hanay (kung saan kailangan naming kopyahin ang mga halaga) at ang haba ng bagong hanay kung saan kinokopya namin ang data. Sa kasong ito, ipinahiwatig namin bilang ang haba numbers.length, dahil Gusto naming kopyahin ang buong array. Kung gusto naming kopyahin lamang ang mga unang elemento, maaari naming tukuyin ang isang mas maliit na haba para sa bagong array:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, 4);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Dito namin tinukoy ang haba ng bagong array na 4. Alinsunod dito, ang unang 4 na elemento lamang numbersang makokopya sa bagong array. Output ng console:

[167, -2, 16, 99]

Sa pamamagitan ng paraan, kung kailangan mong kopyahin ang bahagi ng isang array, ngunit hindi mula sa simula, ngunit "mula sa gitna," Arraysmagagawa mo rin ito:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOfRange(numbers, 2,6);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Konklusyon:

[16, 99, 26, 92]

Ang mga numero mula sa mga cell dalawa ( inclusive ) hanggang anim ( not inclusive ) ay kinopya sa bagong array. Bilang karagdagan, maaaring kailanganin nating ihambing ang dalawang array sa isa't isa. Tulad ng pamamaraan toString(), ang mga array mismo ay hindi nilalampasan ang pamamaraan equals(). Kaya kung susubukan nating ihambing ang mga ito tulad nito:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {1, 2, 3};
       int[] numbers2 = {1, 2, 3};

       System.out.println(numbers.equals(numbers2));
   }
}

makuha namin ang resulta false. Object.equals()Pagkatapos ng lahat, ang paraan na naghahambing ng mga link ay tatawagin . At syempre iba sila! Ngunit kailangan nating ihambing ang mga nilalaman ng mga array, hindi ang mga link. Ang klase Arraysay naglalaman ng isang na-override na paraan equals()na ginagawa kung ano mismo ang kailangan namin:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {1, 2, 3};
       int[] numbers2 = {1, 2, 3};

       System.out.println(Arrays.equals(numbers, numbers2));
   }
}

Konklusyon:

true

Sa pamamagitan ng paraan, Arraysmatagumpay na gumagana ang klase hindi lamang sa mga ordinaryong array, kundi pati na rin sa mga two-dimensional:

public class Main {

   public static void main(String[] args) {

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

       int[][] numbersCopy = Arrays.copyOf(numbers, numbers.length);

       System.out.println("Are these two-dimensional arrays equal to each other?");
       System.out.println(Arrays.deepEquals(numbers, numbersCopy));

       System.out.println(Arrays.deepToString(numbersCopy));
   }
}

Konklusyon:

Равны ли эти двумерные массивы между собой?
true
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Tulad ng nakikita mo, ang pamamaraan Arrays.copyOf()ay nakayanan ang pagkopya ng isang dalawang-dimensional na hanay. Pakitandaan na sa kasong ito, kapag kumukopya ng two-dimensional array, nangyayari ang tinatawag na "shallow copy". At para sa paghahambing ng dalawang-dimensional na mga array at pag-output ng mga ito sa console, ang mga espesyal na pamamaraan ay ibinigay - deepEqualsat deepToString(); Sa hinaharap, makikita mo ang higit sa isang beses (at magiging masaya tungkol dito) na ang mga tagalikha ng Java ay nakakita ng maraming tipikal na sitwasyon na nakakaharap ng mga programmer kapag nagtatrabaho, at nagpatupad ng mga handa na solusyon para sa kanila sa wika. Ang paggamit ng mga solusyong ito ay mas madali at mas maginhawa kaysa sa muling pag-imbento ng mga gulong, tama ba? :) Tiyaking basahin ang dokumentasyon ng klase Arrayssa website ng Oracle . Good luck sa iyong pag-aaral!