Mga koleksyon sa Java | Mga Koleksyon ng Java

Kamusta! Sa nakalipas na ilang mga aralin, gumawa kami ng mahusay na pag-unlad sa pag-master ng ArrayList. Gayunpaman, sa panahong ito ginawa lamang namin ang pinakasimpleng mga operasyon: pagtanggal, pagpasok, pag-output sa console. Siyempre, hindi ito ang katapusan ng listahan ng mga problemang kinakaharap ng mga developer kapag gumagamit ng ArrayList . Tandaan ang panayam tungkol sa mga array at sa klase ng Arrays ? Ito ay binuo ng mga tagalikha ng Java partikular na upang malutas ang mga karaniwang problema na kinakaharap ng mga programmer kapag nagtatrabaho sa mga array. Paano ang tungkol sa ArrayList ? Tiyak na may ilang listahan din ng mga tipikal na gawain para sa kanya. Naipatupad ba silang lahat sa ilang hiwalay na klase, o kailangan nating isulat nang manu-mano ang nais na gawi sa bawat pagkakataon? Siyempre, hindi mo kailangang isulat ang lahat sa iyong sarili. Ang pinakakaraniwang mga operasyon na ginagawa kapag gumagamit ng mga koleksyon sa Java ay naipatupad na sa isang espesyal na static na klase na Mga Koleksyon.

Mga koleksyon sa Java

Ang "Collections" ay isang generic na pangalan para sa ilang istruktura ng data sa Java. Maaaring maimbak ang data sa maraming iba't ibang paraan. Sa ngayon, pinag-aralan lang namin ang klase ng ArrayList , kung saan nakaimbak ang data sa isang array. Makikilala natin ang iba pang mga koleksyon mamaya. Ngayon ay sapat na upang maunawaan na ang klase ng Mga Koleksyon ay idinisenyo upang gumana hindi lamang sa ArrayList, kundi pati na rin sa iba pang mga uri ng mga koleksyon sa Java (kaya, sa katunayan, ang pangalan nito). Kaya, anong mga gawain ang pinapayagan ka ng klase ng Collections na lutasin kapag nagtatrabaho sa ArrayList? Ang una at pinaka-halata ay ang pag-uuri. Sa panayam sa mga array, tumingin kami sa isang halimbawa na may mga numero, at ngayon tingnan natin ang isang halimbawa na may mga string. Upang pagbukud-bukurin ang mga nilalaman ng mga koleksyon, ipinapatupad ng klase ng Mga Koleksyon ang sumusunod na pamamaraan sort():

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       System.out.println(solarSystem);

   }
}

Konklusyon:

[Венера, Земля, Марс, Меркурий, Нептун, Сатурн, Уран, Юпитер]

Ang mga linya ay pinagsunod-sunod ayon sa alpabeto! Bakit in alphabetical order? Ang klase Stringay naka-program upang matukoy nang eksakto kung paano inihahambing ang mga string sa bawat isa (tiyak ayon sa alpabeto). Para sa mga klase na ikaw mismo ang gagawa, maaari mong ipatupad ang iyong sariling mekanismo ng paghahambing, ngunit pag-uusapan natin ito sa ibang mga lektura. Bukod pa rito, pinapayagan ka ng klase ng Collections na mahanap ang minimum at maximum na elemento sa isang ArrayList. Ginagawa ito gamit ang min()at mga pamamaraan max():

public static void main(java.lang.String[] args) {

   ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7));
   System.out.println(Collections.max(numbers));
   System.out.println(Collections.min(numbers));

}

Konklusyon:

7
1

Ito, siyempre, ay mas maginhawa kaysa sa manu-manong pagsulat ng code upang dumaan sa lahat ng mga elemento at maghanap para sa pinakamalaki/pinakamaliit na elemento :) Ang isa pang lubhang kapaki-pakinabang na paraan ay reverse(). Kung kailangan nating "baligtarin" ang isang listahan upang ang mga elemento ay nasa reverse order, paano natin ito gagawin? Malamang na hindi ganoon kadali ang pagsulat ng ganoong algorithm sa iyong sarili :) Sa kabutihang palad, reverse()alam na ng pamamaraan kung paano ito gagawin. Halimbawa, hindi namin gusto kung paano sort()pinagsunod-sunod ng pamamaraan ang aming mga planeta sa alpabetikong pagkakasunud-sunod, at gusto naming baguhin ang pagkakasunod-sunod sa reverse - mula Z hanggang A:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       Collections.reverse(solarSystem);
       System.out.println(solarSystem);

   }
}

Konklusyon:

[Юпитер, Уран, Сатурн, Нептун, Меркурий, Марс, Земля, Венера]

Sa pamamagitan ng paraan, dito madalas nating pinag-uusapan ang pag-uuri, pagkakasunud-sunod ng mga elemento, atbp. Paano kung ang ating gawain ay eksaktong kabaligtaran? Halimbawa, sinusubukan naming ipatupad ang mekanismo ng lottery. Nagdagdag kami ng 100 numero sa reel, na dapat lumabas sa screen nang paisa-isa. Ang unang kalahok na i-cross out ang lahat ng mga numero sa kanilang tiket ay panalo. Napakadaling ipatupad ang gayong mekanismo gamit ang pamamaraan shuffle():

public class Main {

   public static void main(java.lang.String[] args) {

       ArrayList<Integer> lottery = new ArrayList<>(100);
       for (int i = 1; i <= 100; i++) {

           lottery.add(i);//add numbers from 1 to 100 to the drum
       }

       Collections.shuffle(lottery);//mix
       System.out.println("Attention! The first 10 numbers appear from the drum!");
       for (int i = 0; i < 10; i++) {

           System.out.println(lottery.get(i));
       }

   }
}

Konklusyon:

Внимание! Из барабана появляются первые 10 чисел!
32
61
4
81
25
8
66
35
42
71

Ganun kasimple! Ang problema ay nalutas, at ang aming piraso ng laro ay nakasulat :) Ngayon, isipin natin ang ibang sitwasyon. Dati, gumawa kami ng listahan solarSystemkung saan nakalista ang mga planeta dito. At tila babagay sa ating lahat, kung hindi para sa isang bagay: maaari mong alisin ang mga elemento mula dito at magdagdag ng mga bago! Ito ay malinaw na hindi ang pag-uugali na inaasahan namin: ang solar system sa aming programa ay dapat na nasa isang hindi nagbabagong estado. Ang klase ng Mga Koleksyon ay may napakakawili-wiling pamamaraan - unmodifiableList(). Lumilikha ito ng hindi nababagong bersyon ng ibinigay na listahan. Imposibleng magdagdag o mag-alis ng elemento dito. Sa kaso ng listahan ng mga planeta ng solar system, ito mismo ang kailangan natin!

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       List<String> solarSystem = Collections.unmodifiableList(new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune)));
       solarSystem.add("Pluto");//try to add a new element
   }
}

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.Collections$UnmodifiableCollection.add(Collections.java:1075)
	at Main.main(Main.java:21)

Error: solarSystemNgayon ay wala ka nang maidaragdag! Ang tanging bagay na kailangan mong bigyang pansin sa kasong ito ay ang uri ng variable ay dapat na List<>, at hindi ArrayList<>(ang pamamaraang ito ay nagbabalik ng isang bagay na eksaktong ganitong uri, karaniwan sa lahat ng uri ng mga listahan). Ang isa pang karaniwang sitwasyon na maaaring mangyari sa panahon ng trabaho ay ang programmer ay nagdagdag ng mga elemento sa maling pagkakasunud-sunod. Kung nangyari ito, at ang Mercury at Neptune ay hindi inaasahang nagbago ng mga lugar, ang sumusunod na pamamaraan ay makakatulong sa amin na itama ang pagkakamaling ito swap():

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(neptune, venus, earth, mars
       , jupiter, saturn, uranus, mercury));// wrong planet order
       System.out.println(solarSystem);

       Collections.swap(solarSystem, solarSystem.indexOf(mercury), solarSystem.indexOf(neptune));
       System.out.println(solarSystem);

   }
}

Ipinasa namin ang aming listahan sa method swap(), pati na rin ang mga indeks ng dalawang elemento na kailangang ipagpalit. Pakitandaan: partikular na gumagana ang pamamaraan sa mga index, at hindi sa mga link. Samakatuwid, dito kailangan namin ng isang pamamaraan ArrayList.indexOf(). Konklusyon:

[Нептун, Венера, Земля, Марс, Юпитер, Сатурн, Уран, Меркурий]

[Меркурий, Венера, Земля, Марс, Юпитер, Сатурн, Уран, Нептун]

Sa wakas, kilalanin natin ang isang napaka-kagiliw-giliw na paraan - disjoint(). Sinusuri nito kung may mga intersection ang dalawang koleksyon, iyon ay, kahit isang magkaparehong elemento. Kung hindi, babalik true, kung oo, babalik false.

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystemPart1 = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars));
       ArrayList<String> solarSystemPart2 = new ArrayList<>(Arrays.asList(jupiter, saturn, uranus, neptune));

       System.out.println(Collections.disjoint(solarSystemPart1, solarSystemPart2));

   }
}

Tulad ng nakikita mo, ang mga elemento sa aming dalawang listahan ay ganap na naiiba, kaya ang mga output ng programa true. Ito ay isang kawili-wili at napaka-kapaki-pakinabang na klase. Tulad ng Arrays, siya ay gumagawa ng maraming gawain, mababang gawain para sa amin, na nagpapahintulot sa amin na tumuon sa iba pang mga bagay. Basahin ang tungkol dito sa dokumentasyon ng Oracle , mayroong iba pang mga pamamaraan doon.