Isa sa mga pinakakaraniwang function na kailangan namin bilang mga developer na nakikitungo sa data ay ang pag-uuri--sa pamamagitan ng kakayahang pag-uri-uriin ang aming data, maaari naming i-optimize ang aming mga algorithm upang tumakbo nang mas mabilis, at mahanap ang data na kailangan nito sa isang bahagi ng oras na ito ay dadalhin sa kung hindi man. Sa aralin ngayon, pag-uusapan natin ang tungkol sa Java Collections sort(). Bilang isang mabilis na eksperimento sa pag-iisip: isipin na naghahanap ka ng isang pangalan sa pamamagitan ng roster ng unibersidad. Maaaring may sampu-sampung libong estudyante sa paaralang ito. Kung ang roster na ibinigay sa iyo ay wala sa pagkakasunud-sunod ng alpabeto, kakailanganin mong i-flip ang bawat solong pahina at tingnang mabuti upang matiyak na hindi mo lalaktawan ang isang solong pangalan kahit saan, hanggang sa huli mong makita ang pangalan na iyong hinahanap. Sa kabilang banda, kung naka-alpabeto ang roster, hindi lang kailangan mong maging mas mahigpit sa iyong paghahanap, ngunit maaari mong madaling tumalon sa seksyon sa roster na may parehong unang titik, at patuloy na tumalon sa mga pahina sa malalaking hakbang hanggang sa mapunta ka sa taong hinahanap mo. Kung mas maraming data ang ginagamit mo, mas mahalaga na ginagamit mo ito nang mabisa at episyente hangga't maaari. Sa artikulong ito, tatalakayin natin kung paano ayusin ang anumang pagpapatupad ng Listahan sa Java (kabilang ang ArrayList) gamit ang paraan ng pag-uuri ng Mga Koleksyon.
Paano Mag-sort ng ArrayList sa Java gamit ang Java Collections sort method
Pag-usapan natin ang Java Collections.sort method. Ang java.util package ay naglalaman ng maraming kapaki-pakinabang na utility at package na kadalasang ginagamit ng mga developer, kabilang ang ArrayList. Ipagpalagay na mayroon kang sumusunod na simpleng programa:
import java.util.*;
import java.io.*;
class Main{
public static void main(String[] args){
List<String> colors = new ArrayList<String>();
colors.add("Red ");
colors.add("Orange");
colors.add("Green");
colors.add("Blue");
}
}
Gusto mong mai-print ang listahan ng mga kulay, ngunit sa alpabetikong pagkakasunud-sunod. Paano mo ito magagawa? Gamit ang java.util.Collections, ang pag-uuri ay kasingdali ng isang one-liner:
Collections.sort(colors);
Ta-da! Ang iyong listahan ng mga kulay ay naayos na sa lugar. Kung ipi-print mo ang listahan, tulad nito:
System.out.println(colors);
Pagkatapos ay makukuha mo ang sumusunod na output:
[Blue, Green, Orange, Red]
Gaano kadali iyon?! Magiging kasingdali lang ang paggamit ng Collections.sort() upang pag-uri-uriin sa pataas na pagkakasunud-sunod ang isang listahan ng mga Integer, Floats, o anumang iba pang simpleng uri ng data para sa bagay na iyon. Ngunit paano kung gusto mong ayusin sa pababang pagkakasunud-sunod? Talagang may mga kaso kung saan ito ay makatuwiran--isipin na mayroon kang listahan ng mga marka ng pagsusulit para sa isang partikular na klase, at gusto mong malaman kung sino ang mga mag-aaral na may pinakamataas na marka. Mas makatuwirang pag-uri-uriin ang listahan sa pababang pagkakasunud-sunod (pinakamataas na mga marka muna), upang ang mga sagot na hinahanap mo ay nasa itaas. Sa kabutihang palad, ang Collections.sort() ay na-overwrite ng isang opsyonal na 2nd parameter, na nagbibigay-daan sa iyong gawin ito:
sort(List l, Comparator c)
Ngunit ano ang isang paghahambing? Well, ang comparator ay simpleng function na naghahambing ng dalawang input at nagbabalik ng numero na kumakatawan sa kung aling input ang mauna. Kung nag-uuri ka ng ArrayList ng mga primitive na uri ng data, binibigyan ka na ng Java Collections ng reverseOrder() comparator. Maaari itong tawaging ganito:
Ngayon, ang mga kulay ay na-reverse na pinagsunod-sunod sa lugar upang kung ipi-print mo ito, makukuha mo ang sumusunod na output:
[Red, Orange, Green, Blue]
Paano gamitin ang Mga Koleksyon upang pagbukud-bukurin ang mga hindi primitive na uri ng data sa Java
Sa ngayon, nakita mo na ang pag-uuri ng ArrayLists ng mga string o ints sa Java gamit ang Collections.sort() na pamamaraan ay kasingdali ng isang linya ng code. Ngunit kadalasan, ang iyong ArrayLists ay mag-iimbak ng mga hindi primitive na uri ng data. Kapag nagtatrabaho ka sa data na may mas kumplikadong mga katangian, gugustuhin mong magsulat ng mga klase upang kumatawan sa mga bagay na ito at kung paano sila ihahambing sa isa't isa gamit ang kanilang mga katangian. Upang galugarin ang isang halimbawa nito, balikan natin ang halimbawa ng pag-uuri ng isang listahan ng mga kulay, ngunit sa pagkakataong ito, sa halip na pag-uri-uriin ang Strings, pag-uuri-uriin natin ang mga bagay na Kulay. Ang aming pangunahing klase ng Kulay ay maaaring magmukhang ganito:
public class Color{
private int r;
private int g;
private int b;
private String name;
Color(String name, int red, int green, int blue){
this.name = name;
this.r = red;
this.g = green;
this.b = blue;
}
}
Upang gawing tugma ang aming klase ng Kulay sa Collections.sort(), upang maunawaan ng Mga Koleksyon kung paano ihambing at pag-uri-uriin ang mga bagay na Kulay, kailangan naming gumawa ng dalawang maliliit na pagbabago:
gawing Maihahambing na bagay ang Kulay (magdagdag ng mga ipinapatupad na Comparable<Object>)
i-override ang compareTo method sa klase (override public int compareTo(Object o))
Sa mga pagbabagong ito, ganito na ang hitsura ng aming klase:
public class Color implements Comparable<Object>{
private int r;
private int g;
private int b;
private String name;
Color(int red int green, int blue, String name){
this.r = red;
this.g = green;
this.b = blue;
this.name = name;
}
@Override
public int compareTo(Object o) {
Color c = (Color) o;
return this.name.compareTo(c.name);
}
}
Pansinin na ang paraan ng compareTo ng Kulay ay tinatawag lamang ang paraan ng compareTo ng String; gagawin ang pag-uuri ayon sa alpabetikong pagkakasunud-sunod. Kung gusto naming ayusin ayon sa pulang halaga sa pataas na pagkakasunud-sunod, halimbawa, maaari naming palitan ang return statement ng return this.r - cr; (kung gusto naming pag-uri-uriin ayon sa berdeng halaga sa pababang pagkakasunud-sunod, ito ay magbabalik ng cg - this.g;). Ngayon, kung tatawagan natin
Collections.sort(colors);
sa isang ArrayList of Colors kaysa sa Strings lang, gagana ito dahil naiintindihan ng Collections kung paano ihambing ang mga Color object. Kung hindi mo gustong ipatupad ang iyong object ng Comparable<Object>, maaari kang magsulat ng comparator para sa iyong klase, at ipasa iyon sa 2-parameter Collections.sort() method. Ino-override ng isang comparator ang isang paraan na public int compare(Object one, Object two), at ginagamit ito ng Collections.sort() method para ihambing ang mga object habang nagbubukod-bukod. Ang isang halimbawa ng SortByName at SortByRed comparator ay ipinatupad sa ibaba:
class SortByName implements Comparator<Color>
{
public int compare(Color a, Color b)
{
return a.name.compareTo(b.name);
}
}
class SortByRGB implements Comparator<Color>
{
public int compare(Color a, Color b)
{
return a.r - b.r;
}
}
Sa pamamagitan nito, maaari ka nang tumawag
Collections.sort(colors, new SortByName());
nang walang klase ng Kulay na aktwal na nagpapatupad ng Comparable, at gagana pa rin ito. Minsan, makikita mong gagawin ito nang in-line, gamit ang mga function ng lambda. Ang isang function ng lambda ay mahalagang isang function na walang pangalan na maaari mong tukuyin sa loob ng linya ng code, na tinatawag ito. Ang mga ito ay kapaki-pakinabang kapag kailangan mo lamang tumawag ng isang function para sa isang partikular na pagkakataon at ayaw mong tukuyin ang isang buong hiwalay na function sa ibang lugar. Ang SortByName comparator ay maaaring tukuyin in-line, gamit ang isang lambda function, tulad nito:
Tulad ng maaaring nahulaan mo, ang (a, b) ay kumakatawan sa mga parameter ng mga function ng lambda (ang dalawang bagay na ihahambing). Ang -> ay nagpapahiwatig na ang sumusunod ay isang kahulugan ng function ng lambda. Iyon lang! Nakita mo na ngayon ang pinakasikat na paraan ng pag-uuri ng ArrayLists sa Java gamit ang Collections package.
GO TO FULL VERSION