Hello ulit! :) Sa aralin ngayon, pag-uusapan natin ang tungkol sa klase ng Arrays sa Java. Sa huling aralin, nalaman natin ang ganitong istruktura ng data na tinatawag na array. Natutunan namin kung paano gawin ang mga ito at punan ang mga ito ng data. At tiningnan namin kung paano sila nakaimbak sa memorya. Ngayon ay titingnan natin ang ilang mga gawain at halimbawa ng pagtatrabaho sa mga arrays na madalas mong makikita sa totoong trabaho. Halimbawa, isipin ang sitwasyong ito: Mayroon kaming hanay ng 10 random na numero.
Ang aming gawain ay pag-uri-uriin ang array na ito sa pataas na pagkakasunud-sunod: mula sa pinakamaliit hanggang sa pinakamalaki. Sa huli, dapat itong magmukhang ganito: [-234, -2, 16, 26, 35, 43, 92, 99, 167] Paano natin gagawin iyon? Ang gawaing ito ay hindi mahalaga. Hindi pa namin nagawa ito dati :/ Any ideas? Hulaan mo. Narito ang isang solusyon:
Pumunta sa lahat ng mga elemento ng array. Ihambing ang bawat elemento sa susunod ([0] sa [1], [1] sa [2], [2] sa [3], atbp.). Kung ang kasalukuyang elemento ay mas malaki kaysa sa susunod, pinapalitan namin ang mga ito, at pagkatapos ay lumipat sa susunod na elemento. Kung hindi, iwanan sila kung ano sila, at magpatuloy
Kaya, pagkatapos ng unang pagpasa sa mga elemento, ang pinakamalaking halaga (167) ay garantisadong nasa huling cell.
Ngayon ay muli nating dadaan ang lahat ng mga elemento, ngunit sa pagkakataong ito ay magsisimula tayo sa index [0] hanggang sa penultimate element (ang pinakamalaking bilang ay nasa lugar na nito) at gagawa ng parehong mga paghahambing at pagpapalit. Pagkatapos ng pass na ito, sa penultimate cell, magkakaroon tayo ng pangalawang pinakamalaking halaga (99).
Ulitin ang prosesong ito nang maraming beses hangga't mayroon tayong mga elemento ng array.
Mayroon kaming ideya. Ngayon kailangan lang nating isulat ang code. Mukhang ganito:
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 not in the right order,
then swap them */
if (numbers[j] > numbers[j + 1]) {
int tmp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = tmp;
}
}
}
}
}
Uh ... Mukhang medyo kumplikado -_- Kahit na ang pangkalahatang prinsipyo ay nauunawaan, kailangan pa rin nating sumulat ng napakaraming code upang malutas ang gayong simpleng gawain. Okay, baka naman masyado lang nating pinahahalagahan ang sarili natin? Ang gawaing napag-usapan namin ay malamang na masyadong kumplikado para sa amin. Subukan natin ang isang bagay na mas simple. Halimbawa, kunin ang parehong array ng numero.
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 alam mo na tungkol sa mga array? Halimbawa, maaari kang dumaan sa array ng mga numero sa isang loop at sunud-sunod na isulat ang mga elemento nito 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, uh, dito na natin talaga nagawa! Mukhang nalutas na namin ang problema. Gayunpaman, kung kailangan mong gawin ito nang madalas, ang iyong code ay magkakaroon ng maraming magkakaparehong mga loop. Sa katunayan, ang mga ito (at iba pang) gawain ay matagal nang nalutas ng mga tagalikha ng Java. Hindi natin kailangang "muling baguhin ang gulong" at i-code ang sarili nating solusyon. Mayroong isang espesyal na static na klase ( Arrays ) upang matulungan kang magsagawa ng mga karaniwang gawain kapag nagtatrabaho sa mga array. Ang mga pamamaraan para sa pagsasagawa ng mga pinakakaraniwang gawain na kinakaharap ng mga Java programmer ay idinagdag sa klase na ito. Halimbawa, ang gawain ng pag-uuri ng isang array, na sinubukan naming hawakan, ay nalutas 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 Arrays.sort() method ay nag-uuri ng array. At ang algorithm nito ay mas mahusay kaysa sa code na isinulat namin. Output ng console: [-234, -2, 16, 26, 35, 43, 80, 92, 99, 167] Tandaan: Upang i-convert ang array sa isang string, gumamit kami ng isa pang paraan ng klase ng Arrays : Arrays.toString() . Ang mga array sa Java ay hindi nag-iisa sa toString() na pamamaraan. Kaya, kung isusulat mo lang
System.out.println(numbers.toString());
ang klase ng Object na toString() ay tatawagin. Para sa isang array, ang output ay magiging katulad nito: [I@4554617c Hindi na natin isa-isahin ngayon ang tungkol sa kung bakit eksaktong ganito ang output. Ang pangunahing bagay ay malinaw na hindi ito ang kailangan natin. Ngunit ginagawa ng Arrays.toString() ang eksaktong gusto natin. Sa pamamagitan ng paraan, ang pagkopya ay madaling magawa sa klase ng 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));
}
}
Ipapasa namin sa Arrays.copyOf() method ang aming orihinal na array (kung saan gusto naming kopyahin ang mga value) at ang haba ng bagong array kung saan kami kumukopya ng data. Sa kasong ito, ipinahiwatig namin ang mga numero.haba bilang haba, dahil gusto mong kopyahin ang buong array. Kung nais naming kopyahin lamang ang mga unang elemento, maaari naming tukuyin ang haba ng isang bagong mas maliit na hanay:
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 4 bilang ang haba ng bagong array. Alinsunod dito, tanging ang unang 4 na elemento ng mga numero ang makokopya sa bagong array. Output ng console: [167, -2, 16, 99] Sa pamamagitan ng paraan, hinahayaan ka rin ng Arrays na kopyahin ang bahagi ng isang array mula sa gitna kaysa sa simula ng 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.copyOfRange(numbers, 2,6);
System.out.println(Arrays.toString(numbersCopy));
}
}
Output: [16, 99, 26, 92] Ang mga numero ay kinopya sa bagong hanay mula sa pangalawang hanay mula sa pangalawa (kabilang) hanggang sa ikaanim (hindi kasama) na elemento. Maaaring kailanganin din nating paghambingin ang dalawang array. Tulad ng paraang toString() , ang mga array mismo ay hindi nag-o-override sa equals() na pamamaraan. Kaya kung susubukan nating ikumpara sila ng ganito
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));
}
}
pagkatapos ay makakakuha tayo ng hindi totoo. Ito ay dahil ang Object.equals() , na naghahambing ng mga sanggunian, ay tatawagin. At, malinaw naman, iba sila! Ngunit ang kailangan natin ay ihambing ang mga nilalaman ng array, hindi mga sanggunian. Ino-override ng klase ng Arrays ang equals() na pamamaraan upang gawin itong eksakto kung ano ang gusto natin:
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));
}
}
Output: true Sa pamamagitan ng paraan, gumagana ang klase ng Arrays 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?");
System.out.println(Arrays.deepEquals(numbers, numbersCopy));
System.out.println(Arrays.deepToString(numbersCopy));
}
}
Output: Magkapantay ba ang mga two-dimensional array na ito? true [[1, 2, 3], [4, 5, 6], [7, 8, 9]] Gaya ng nakikita mo, nagawang kopyahin ng Arrays.copyOf() method ang isang two-dimensional array. At ang klase ay may mga espesyal na pamamaraan para sa paghahambing at pagpapakita ng dalawang-dimensional na array: deepEquals at deepToString() . Sa hinaharap, paulit-ulit mong makikita (at magagalak sa katotohanang) na ang mga tagalikha ng Java ay inaasahan ang maraming sitwasyon na madalas na kinakaharap ng mga programmer, 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 gulong, tama ba? :) Tiyaking basahin ang dokumentasyon para sa klase ng Arrays sa website ng Oracle . Good luck sa iyong pag-aaral!
GO TO FULL VERSION