Klase ng koleksyon sa Java

Hi! Sa nakalipas na ilang mga aralin, gumawa kami ng malaking pag-unlad sa aming karunungan sa ArrayList. Gayunpaman, sa ngayon ang pinakasimpleng operasyon lang ang ginawa namin: alisin, ipasok, at ipakita. Siyempre, hindi nito saklaw ang buong listahan ng mga gawain na dapat gawin ng mga developer kapag nagtatrabaho sa ArrayList. Tandaan ang aralin tungkol sa mga array at ang Arraysklase? Partikular na idinisenyo ng mga tagalikha ng Java ang klase na ito upang pangasiwaan ang mga pinakakaraniwang gawaing kinakaharap ng mga programmer kapag nagtatrabaho sa mga array. At ano namanArrayList? Tiyak, mayroong ilang listahan ng mga karaniwang gawain na kailangang gampanan kasama nito. Naipatupad ba silang lahat sa isang partikular na klase, o kailangan ba nating magsulat ng sarili nating pagpapatupad sa bawat oras? Siyempre, hindi mo kailangang isulat ang lahat sa iyong sarili. Ang pinakakaraniwang mga operasyon na kinasasangkutan ng mga koleksyon ay naipapatupad na sa espesyal na static Collectionsna klase. Sa Java, ang isang pangkat ng mga istruktura ng data ay karaniwang tinutukoy bilang isang koleksyon . Maaaring maimbak ang data sa maraming iba't ibang paraan. Sa ngayon, pinag-aralan lang namin ang ArrayListklase, kung saan nakaimbak ang data sa isang array. Makikilala natin ang iba pang mga koleksyon mamaya. Sa ngayon, sapat na na maunawaan lamang na ang Collectionsklase ay idinisenyo upang gumana hindi lamang saArrayList, ngunit pati na rin sa iba pang mga uri ng mga koleksyon (samakatuwid, ang pangalan nito). Kaya, anong mga gawain ang Collectionstalagang tinutulungan ng klase kapag nagtatrabaho sa ArrayList? Ang una at pinaka-halata ay ang pag-uuri. Sa aralin tungkol sa mga array, isinasaalang-alang namin ang isang halimbawa na may mga numero. Ngayon ay isasaalang-alang namin ang isang halimbawa na may mga string. CollectionsIpinapatupad ng klase ang sort()pamamaraan para sa pag-uuri ng mga nilalaman ng mga koleksyon:

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);

   }
}

Output: [Earth, Jupiter, Mars, Mercury, Neptune, Saturn, Uranus, Venus] Ang mga string ay pinagsunod-sunod ayon sa alpabeto! Pero bakit alphabetically? Ang Stringklase ay aktwal na nagpapatupad ng lohika na namamahala sa kung paano inihahambing ang mga string (na nangyayari na ayon sa alpabeto). Para sa mga klase na ikaw mismo ang gumawa, maaari mong ipatupad ang sarili mong lohika ng paghahambing, ngunit pag-uusapan natin ito sa ibang mga aralin. Tinutulungan ka rin ng Collectionsklase na mahanap ang minimum at maximum na elemento sa isang ArrayList. Ginagawa ito gamit ang min()at max()mga pamamaraan:

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));

}

Output: 7 1 Naturally, ito ay mas maginhawa kaysa sa manu-manong pagsulat ng code upang umulit sa lahat ng mga elemento at hanapin ang pinakamalaki/pinakamaliit na elemento :) Isa pang napaka-kapaki-pakinabang na paraan ay reverse(). Kung kailangan nating "i-flip" ang listahan upang ang mga elemento ay pumunta sa kabaligtaran na pagkakasunud-sunod, paano natin ito gagawin? Malamang na hindi ganoon kadali ang sumulat ng ganoong algorithm nang mag-isa :) Sa kabutihang palad, reverse()alam na ng pamamaraan kung paano. Ipagpalagay na hindi namin gusto ang katotohanan na sort()pinagsunod-sunod ng pamamaraan ang aming mga planeta ayon sa alpabeto, at gusto naming baligtarin ang kanilang pagkakasunud-sunod: 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);

   }
}

Output: [Venus, Uranus, Saturn, Neptune, Mercury, Mars, Jupiter, Earth] Marami na tayong pinag-uusapan tungkol sa pag-uuri, pagkakasunud-sunod ng mga elemento, atbp. Ngunit paano kung magkasalungat ang layunin natin? Halimbawa, ipagpalagay na sinusubukan naming ipatupad ang isang larong bingo. Nagdagdag kami ng 100 numero sa drum. Dapat silang lumabas sa screen nang paisa-isa. Ang unang manlalaro na i-cross out ang lahat ng mga numero sa kanyang tiket ay mananalo. Ito ay madaling ipatupad gamit ang shuffle()pamamaraan:

public class Main {

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

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

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

       Collections.shuffle(bingoDrum);// Mix it up
       System.out.println ("Your attention, please! Here are the first 10 numbers from the drum!");
       for (int i = 0; i < 10; i++) {

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

   }
}

Output: Ang iyong pansin, mangyaring! Narito ang unang 10 numero mula sa drum! 32 61 4 81 25 8 66 35 42 71 Ganun lang kadali! Ang problema ay nalutas, at ang aming bahagi ng laro ay nakasulat :) Ngayon, isipin natin ang ibang sitwasyon. Dati, gumawa kami ng solarSystemlistahan na naglalaman ng mga planeta. At tila babagay ito sa amin sa lahat ng paraan maliban sa isa: maaari mong tanggalin ang mga item mula dito at magdagdag ng mga bago ! Ito ay malinaw na hindi ang pag-uugali na inaasahan namin: Ang solar system ay dapat na hindi nababago sa aming programa. Ang Collectionsklase ay may isang napaka-kagiliw-giliw na pamamaraan: unmodifiableList(). Lumilikha ito ng hindi nababagong listahan mula sa listahang ipinasa bilang argumento. Hindi ka maaaring magdagdag o magtanggal ng mga item mula sa listahang ito. Kapag nakikitungo sa listahan ng mga planeta sa solar system, ito mismo ang gusto 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
   }
}

Output: Exception sa thread na "main" java.lang.UnsupportedOperationException sa java.util.Collections$UnmodifiableCollection.add(Collections.java:1075) sa Main.main(Main.java:21) Ito ay isang error: hindi mo magagawa magdagdag ng kahit ano sa solarSystem! Ang tanging bagay na kailangan mong bigyang pansin dito ay ang katotohanan na ang pamamaraang ito ay nagbabalik List<>(hindi ArrayList<>), dahil ang ganitong uri ay karaniwan para sa lahat ng uri ng mga listahan. Ang isa pang medyo karaniwang sitwasyon na madaling mangyari ay para sa programmer na magdagdag ng mga elemento sa maling pagkakasunud-sunod. Kung nangyari ito at nakita namin na pinaghalo ang Mercury at Neptune, maaari naming itama ang pagkakamaling ito gamit ang swap()pamamaraan:

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));// The planets are in the wrong order
       System.out.println(solarSystem);

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

   }
}

Ipinapasa namin sa swap()pamamaraan ang aming listahan at ang mga indeks ng dalawang elemento na kailangang ipagpalit. Tandaan na gumagana ang pamamaraan sa mga indeks, hindi sa mga sanggunian. Kaya, narito kailangan naming gamitin ang ArrayList.indexOf()pamamaraan. Output: [Neptune, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Mercury] [Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune] Sa wakas, makikilala natin ang isang napaka-kawili-wiling paraan : disjoint(). Sinusuri nito kung ang dalawang koleksyon ay nagsalubong, ibig sabihin, kung mayroon silang hindi bababa sa isang magkaparehong elemento . Kung hindi nila gagawin, ito ay nagbabalik ng totoo. Ginagawa nila ito, pagkatapos ay nagbabalik ng mali

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 aming dalawang listahan ay may ganap na magkakaibang mga elemento, kaya ang mga output ng programa ay totoo . Ito ay isang kawili-wili at napaka-kapaki-pakinabang na klase. Tulad ng Arrays, ito ay gumagawa ng maraming gawain, nakakapagod na trabaho para sa amin, na nagpapahintulot sa amin na tumuon sa iba pang mga bagay.