Comparator, pag-uuri ng mga koleksyon

"Hi, Amigo!"

"Hi, Bilaabo!"

"Ngayon ay susuriin natin ang isang maliit, ngunit kawili-wili at kapaki-pakinabang na paksa: pag-uuri ng mga koleksyon."

"Sorting? May narinig ako tungkol diyan."

"Matagal na ang nakalipas, ang bawat programmer ay kailangang magsulat ng mga algorithm sa pag-uuri. Nagawa at kinailangan niyang isulat ang mga ito. Ngunit natapos na ang mga araw na iyon. Ngayon, ang pagsulat ng iyong sariling sorting code ay itinuturing na masamang anyo, tulad ng muling pagsulat ng anumang bagay na mayroon na. naimbento."

"Sa Java (at iba pang mga programming language), naipatupad na ang pag-uuri.  Ang iyong gawain ay matutunan kung paano gamitin nang maayos ang mayroon na. "

"OK."

"Ang klase ng Helper ng Collections ay may static na paraan ng pag-uuri na ginagamit upang pag-uri-uriin ang mga koleksyon—o mas tiyak, mga listahan. Ang mga Elemento sa Maps at Sets ay walang order/index, kaya walang dapat ayusin."

"Oo, natatandaan ko. Ginamit ko ang pamamaraang ito minsan para pagbukud-bukurin ang isang listahan ng mga numero."

"Mahusay. Ngunit ang pamamaraang ito ay mas makapangyarihan kaysa sa tila sa unang tingin. Maaari itong mag-uri-uriin hindi lamang ng mga numero, kundi pati na rin ang anumang mga bagay, batay sa anumang pamantayan. Nakakatulong ang dalawang interface sa pamamaraan na gawin ito: Comparable at Comparator . "

"Minsan kailangan mong pagbukud-bukurin ang mga bagay, hindi mga numero. Halimbawa, ipagpalagay na mayroon kang listahan ng mga tao, at gusto mong pagbukud-bukurin sila ayon sa edad. Mayroon kaming Comparable interface para dito."

"Hayaan mo muna akong magpakita sa iyo ng isang halimbawa, at pagkatapos ay magiging mas malinaw ang lahat:"

public class Woman implements Comparable<Woman>
{
public int age;

public Woman(int age) {
this.age = age;
}

public int compareTo(Woman o)
{
return this.age - o.age;
}
}

public static void main(String[] args )
{
ArrayList<Woman> women = new ArrayList<Woman>();
women.add(new Woman(18));
women.add(new Woman(21));
women.add(new Woman(5));

Collections.sort(women);
}

"Upang pag-uri-uriin ang mga bagay, kailangan mo munang malaman kung paano ihambing ang mga ito. Para dito, ginagamit namin ang Comparable. Ang Comparable interface ay isang generic, na nangangahulugang tumatanggap ito ng isang uri ng argumento. Mayroon lamang itong isang generic na paraan: compareTo(T o). Ang pamamaraang ito ay naghahambing sa kasalukuyang bagay (ito) at isang bagay na ipinasa bilang isang argumento (o). "

"At paano gumagana ang compareTo? Inaasahan ko na ito ay magbabalik ng totoo o mali depende sa kung ang naipasa na bagay ay mas malaki o mas maliit."

"Mas nakakalito ang mga bagay dito. Ang compareTo method ay hindi nagbabalik ng true/false. Sa halip, nagbabalik ito ng int. Ito ay aktwal na ginagawa para sa pagiging simple.

"Kapag ang isang computer ay kailangang matukoy kung ang isang numero ay mas malaki kaysa sa isa pa, binabawasan lamang nito ang pangalawang numero mula sa una at pagkatapos ay titingnan ang resulta. Kung ang resulta ay 0, ang mga numero ay pantay. Kung ang resulta ay mas mababa sa zero , kung gayon ang pangalawang numero ay mas malaki. At kung ang resulta ay mas malaki kaysa sa zero, kung gayon ang unang numero ay mas malaki."

"Ang parehong lohika ay nalalapat dito. Ayon sa detalye, ang compareTo method ay dapat magbalik ng zero kung ang pinaghahambing na mga bagay ay pantay. Kung ang compareTo method ay nagbabalik ng isang numero na mas malaki kaysa sa zero, kung gayon ang ating object ay mas malaki kaysa sa naipasa na object. "Kung ang compareTo paraan ay nagbabalik ng isang numero na mas mababa sa zero, pagkatapos 'ito' ay mas mababa kaysa sa naipasa na bagay."

"Medyo kakaiba iyon."

"Oo, ngunit kung naghahambing ka ng mga bagay batay lamang sa ilang numeric na ari-arian, maaari mo lamang ibalik ang pagkakaiba sa pagitan ng mga ito sa pamamagitan ng pagbabawas ng isa mula sa isa. Tulad ng ginawa sa halimbawa sa itaas."

public int compareTo(Woman o)
{
return this.age - o.age;
}

"I think I understand everything. Pero hindi naman siguro. Pero halos lahat."

"Mahusay. Ngayon isaalang-alang natin ang isang mas praktikal na problema. Ipagpalagay na nagsulat ka ng isang cool na website para sa paggawa ng mga damit ng kababaihan sa China. Gumagamit ka ng klase ng Babae upang ilarawan ang iyong mga customer. Gumawa ka pa ng isang webpage na may isang talahanayan kung saan makikita mo silang lahat . Pero may problema..."

"Ang object ng iyong Babae ay naglalaman ng hindi lamang isang edad, kundi pati na rin ang isang buong grupo ng iba pang data: pangalan, apelyido, taas, timbang, bilang ng mga bata, atbp."

"Maraming column ang talahanayan ng mga user, at narito ang tanong: paano mo pinag-uuri-uriin ang iyong mga user ayon sa iba't ibang pamantayan? Ayon sa timbang, ayon sa edad, ayon sa apelyido?"

"Hmm. Yeah, I often see tables that let you sort by column. So, how do you do that?"

"Para dito, mayroon kaming pangalawang interface na gusto kong sabihin sa iyo ngayon: ang Comparator interface. Mayroon din itong paraan ng paghahambing, ngunit nangangailangan ito ng dalawang argumento, hindi isa: int compare(T o1, T o2). Ganito ito gumagana :"

public class Woman
{
public int age;
public int childrenCount;
public int weight;
public int height;
public String name;

public Woman(int age) {
this.age = age;
}
}

public static void main(String[] args )
{
ArrayList<Woman> women = new ArrayList<Woman>();
women.add(new Woman(18));
women.add(new Woman(21));
women.add(new Woman(5));

Comparator<Woman> compareByHeight = new Comparator<Woman>() {
public int compare(Woman o1, Woman o2) {
return o1.height - o2.height;
}
};

Collections.sort(women, compareByHeight);
}

"Hindi itinatago ng interface ng Comparator ang lohika ng paghahambing ng bagay sa loob ng klase ng mga bagay na inihahambing. Sa halip, ipinatupad ito sa isang hiwalay na klase."

"Kaya, maaari akong gumawa ng ilang klase na nagpapatupad ng interface ng Comparator, at ipahambing sa bawat isa sa kanila ang iba't ibang katangian? Timbang sa isa, edad sa isa pa, at taas sa pangatlo?"

"Oo, ito ay napaka-simple at maginhawa."

"Tinatawag lang namin ang paraan ng Collections.sort , na nagpapasa ng listahan ng mga bagay at isa pang espesyal na bagay bilang pangalawang argumento, na nagpapatupad ng interface ng Comparator at nagsasabi sa iyo kung paano ihambing nang tama ang mga pares ng mga bagay sa proseso ng pag-uuri."

"Hmm. Sa tingin ko naiintindihan ko ang lahat. Subukan ko ito. Sabihin nating kailangan kong pagbukud-bukurin ang mga user ayon sa timbang. Ito ay magiging ganito:"

Comparator<Woman> compareByWeight = new Comparator<Woman>() {
public int compare(Woman o1, Woman o2) {
return o1.weight - o2.weight;
}
};

Collections.sort(women, compareByWeight);

"Oo eksakto."

"Great. Pero paano kung gusto kong ayusin sa reverse order?"

"Pag-isipan mo. Napakasimple ng sagot!"

"Nakuha ko na! Ganito:"

return o1.weight - o2.weight;

return o2.weight – o1.weight;

"Tama. Magaling."

"At kung gusto kong pagbukud-bukurin ayon sa apelyido? Paano ako mag-uuri ng mga string, Bilaabo?"

"Ang String class ay nagpapatupad na ng compareTo method. Kailangan mo lang itong tawagan:"

Comparator<Woman> compareByName = new Comparator<Woman>() {
public int compare(Woman o1, Woman o2) {
return o1.name.compareTo(o2.name);
}
};

Collections.sort(women, compareByName);

"Magandang aral iyon, Bilaabo. Maraming salamat."

"At salamat sa iyo, aking kaibigan!"