Jebkura atsevišķu objektu grupa, kas ir attēlota kā viena vienība, ir pazīstama kā Java objektu kolekcija. Java versijā atsevišķa sistēma ar nosaukumu Kolekcijas ietvars ir definēts JDK 1.2, kurā ir visas Java kolekcijas klases un interfeiss.
Java, kolekcijas interfeiss ( java.util.Collection ) un kartes interfeiss ( java.util.Map ) ir divas galvenās Java kolekcijas klašu saknes saskarnes.
Kas jums jāapgūst Java kolekcijās?
- Saraksta interfeiss
- Abstract List Class
- Abstract Sequential List Class
- Masīvu saraksts
- Vektoru klase
- Stack Class
- LinkedList klase
- Rindas interfeiss
- Bloķēšanas rindas interfeiss
- AbstractQueue klase
- PriorityQueue klase
- PriorityBlockingQueue klase
- ConcurrentLinkedQueue klase
- ArrayBlockingQueue klase
- DelayQueue klase
- LinkedBlockingQueue klase
- LinkedTransferQueue
- Un interfeiss
- BlockingDeque interfeiss
- ConcurrentLinkedDeque klase
- ArrayDeque klase
- Iestatīt interfeisu
- Abstract Set Class
- CopyOnWriteArraySet klase
- EnumSet klase
- Paralēlā HashMap klase
- HashSet klase
- LinkedHashSet klase
- SortedSet interfeiss
- NavigableSet interfeiss
- TreeSet
- ConcurrentSkipListSet klase
- Kartes interfeiss
- Sakārtotās kartes interfeiss
- NavigableMap interfeiss
- ConcurrentMap interfeiss
- TreeMap klase
- AbstractMap klase
- Paralēlā HashMap klase
- EnumMap klase
- HashMap klase
- IdentityHashMap klase
- LinkedHashMap klase
- HashTable klase
- Rekvizītu klase
- Citi svarīgi jēdzieni
- Kā pārvērst HashMap uz ArrayList
- Nejauši atlasiet vienumus no saraksta
- Kā pievienot visus vienumus no kolekcijas ArrayList
- Java karšu konvertēšana uz sarakstu
- Masīva uz ArrayList konvertēšana
- ArrayList konvertēšana uz masīvu
- Atšķirības starp Array un ArrayList
Kas ir ietvars Java?
Ietvars ir klašu un saskarņu kopums, kas nodrošina gatavu arhitektūru. Lai ieviestu jaunu līdzekli vai klasi, nav nepieciešams definēt ietvaru. Tomēr optimālais objektorientētais dizains vienmēr ietver ietvaru ar klašu kolekciju, lai visas klases veiktu vienu un to pašu uzdevumu.
Nepieciešams atsevišķs Java kolekcijas ietvars
Pirms kolekcijas ietvara (vai pirms JDK 1.2) ieviešanas tika izmantotas standarta metodes Java objektu (vai kolekciju) grupēšanai. Masīvi vai Vektori , vai Hashtables . Visām šīm kolekcijām nebija kopīga saskarnes. Tāpēc, lai gan visu kolekciju galvenais mērķis ir vienāds, visu šo kolekciju realizācija tika noteikta neatkarīgi, un tām nebija nekādas korelācijas. Un arī lietotājiem ir ļoti grūti atcerēties visu atšķirīgo metodes , sintakse un konstruktori klāt katrā kolekcijas klasē.
Izpratīsim to ar elementa pievienošanas piemēru hashtable un vektoram.
cik unces ir 10 mililitri
Piemērs:
Java
// Java program to demonstrate> // why collection framework was needed> import> java.io.*;> import> java.util.*;> class> CollectionDemo {> >public> static> void> main(String[] args)> >{> >// Creating instances of the array,> >// vector and hashtable> >int> arr[] =>new> int>[] {>1>,>2>,>3>,>4> };> >Vector v =>new> Vector();> >Hashtable h =>new> Hashtable();> >// Adding the elements into the> >// vector> >v.addElement(>1>);> >v.addElement(>2>);> >// Adding the element into the> >// hashtable> >h.put(>1>,>'geeks'>);> >h.put(>2>,>'4geeks'>);> >// Array instance creation requires [],> >// while Vector and hastable require ()> >// Vector element insertion requires addElement(),> >// but hashtable element insertion requires put()> >// Accessing the first element of the> >// array, vector and hashtable> >System.out.println(arr[>0>]);> >System.out.println(v.elementAt(>0>));> >System.out.println(h.get(>1>));> >// Array elements are accessed using [],> >// vector elements using elementAt()> >// and hashtable elements using get()> >}> }> |
>
>Izvade
1 1 geeks>
Kā mēs varam novērot, neviena no šīm kolekcijām (Array, Vector vai Hashtable) neievieš standarta dalībnieku piekļuves saskarni, programmētājiem bija ļoti grūti uzrakstīt algoritmus, kas varētu darboties visu veidu kolekcijām. Vēl viens trūkums ir tas, ka lielākā daļa “Vector” metožu ir galīgas, kas nozīmē, ka mēs nevaram paplašināt “Vector” klasi, lai ieviestu līdzīga veida kolekciju. Tāpēc Java izstrādātāji nolēma izstrādāt kopīgu saskarni, lai risinātu iepriekš minētās problēmas, un JDK 1.2 ziņā ieviesa kolekcijas ietvaru, kurā gan mantotie vektori, gan hashtables tika pārveidoti, lai tie atbilstu kolekcijas ietvaram.
Java kolekcijas ietvara priekšrocības
Tā kā savākšanas sistēmas trūkums radīja iepriekš minēto trūkumu kopumu, tālāk ir norādītas savākšanas sistēmas priekšrocības.
- Konsekventa API: API ir pamata saskarņu komplekts, piemēram Kolekcija , Iestatīt , Saraksts , vai Karte , ir visas klases (ArrayList, LinkedList, Vector utt.), kas ievieš šīs saskarnes daži kopīgs metožu kopums.
- Samazina programmēšanas piepūli: Programmētājam nav jāuztraucas par kolekcijas dizainu, bet viņš var koncentrēties uz tās labāko izmantošanu savā programmā. Līdz ar to ir veiksmīgi realizēta Objektorientētās programmēšanas (t.i.) abstrakcijas pamatkoncepcija.
- Palielina programmas ātrumu un kvalitāti: Palielina veiktspēju, nodrošinot augstas veiktspējas noderīgu datu struktūru un algoritmu ieviešanu, jo šajā gadījumā programmētājam nav jādomā par labāko konkrētas datu struktūras ieviešanu. Viņš var vienkārši izmantot labāko ieviešanu, lai krasi palielinātu sava algoritma/programmas veiktspēju.
Kolekcijas ietvara hierarhija Java
Lietderības pakotnē (java.util) ir visas klases un saskarnes, kas nepieciešamas kolekcijas ietvaram. Kolekciju ietvars satur interfeisu ar nosaukumu iterējams interfeiss, kas nodrošina iteratoram visu kolekciju atkārtošanu. Šo saskarni paplašina galvenais kolekcijas interfeiss, kas darbojas kā kolekcijas sistēmas sakne. Visas kolekcijas paplašina šo kolekcijas saskarni, tādējādi paplašinot iteratora īpašības un šīs saskarnes metodes. Nākamajā attēlā ir parādīta kolekcijas struktūras hierarhija.
Pirms dažādu komponentu izpratnes iepriekš minētajā sistēmā, vispirms izprotam klasi un saskarni.
- Klase : Klase ir lietotāja definēts projekts vai prototips, no kura tiek izveidoti objekti. Tas attēlo īpašību vai metožu kopu, kas ir kopīgas visiem viena veida objektiem.
- Interfeiss : Tāpat kā klasei, saskarnei var būt metodes un mainīgie, taču saskarnē deklarētās metodes pēc noklusējuma ir abstraktas (tikai metodes paraksts, neviens). Saskarnes norāda, kas klasei ir jādara, nevis kā. Tas ir klases plāns.
Kolekcijas saskarnes metodes
Šajā saskarnē ir ietvertas dažādas metodes, kuras var tieši izmantot visas kolekcijas, kas ievieš šo saskarni. Viņi ir:
| Metode | Apraksts |
|---|---|
| pievienot (objekts) | Šo metodi izmanto, lai kolekcijai pievienotu objektu. |
| pievienot visu (c kolekcija) | Šī metode šai kolekcijai pievieno visus dotajā kolekcijā esošos elementus. |
| skaidrs () | Izmantojot šo metodi, no šīs kolekcijas tiek noņemti visi elementi. |
| satur (Objekts o) | Šī metode atgriež patieso vērtību, ja kolekcijā ir norādītais elements. |
| satur visu (c kolekcija) | Šī metode atgriež patieso vērtību, ja kolekcijā ir visi attiecīgās kolekcijas elementi. |
| vienāds (Objekts o) | Šī metode salīdzina norādīto objektu ar šo vienlīdzības kolekciju. |
| hashCode() | Šī metode tiek izmantota, lai atgrieztu šīs kolekcijas jaucējkoda vērtību. |
| ir tukšs() | Šī metode atgriež patieso vērtību, ja šajā kolekcijā nav elementu. |
| iterators () | Šī metode atgriež iteratoru pār šīs kolekcijas elementiem. |
| max() | Šo metodi izmanto, lai atgrieztu maksimālo kolekcijā esošo vērtību. |
| parallelStream() | Šī metode atgriež paralēlu straumi, kuras avots ir šī kolekcija. |
| noņemt (Objekts o) | Šo metodi izmanto, lai noņemtu doto objektu no kolekcijas. Ja ir vērtību dublikāti, šī metode noņem pirmo objekta gadījumu. |
| noņemt visu (c kolekcija) | Šo metodi izmanto, lai no kolekcijas izņemtu visus dotajā kolekcijā minētos objektus. |
| removeIf (predikātu filtrs) | Šo metodi izmanto, lai noņemtu visus šīs kolekcijas elementus, kas atbilst dotajam predikāts . |
| paturēt visu (c kolekcija) | Šī metode tiek izmantota, lai saglabātu tikai tos šīs kolekcijas elementus, kas ir ietverti norādītajā kolekcijā. |
| Izmērs() | Šo metodi izmanto, lai atgrieztu kolekcijas elementu skaitu. |
| sadalītājs () | Šo metodi izmanto, lai izveidotu a Sadalītājs pāri šīs kolekcijas elementiem. |
| straume () | Šī metode tiek izmantota, lai atgrieztu secīgu straumi, kuras avots ir šī kolekcija. |
| toArray() | Šo metodi izmanto, lai atgrieztu masīvu, kurā ir visi šīs kolekcijas elementi. |
Saskarnes, kas paplašina Java kolekciju saskarni
Vākšanas ietvars satur vairākas saskarnes, kur katra saskarne tiek izmantota noteikta veida datu glabāšanai. Tālāk ir norādītas ietvarā esošās saskarnes.
1. Atkārtojams interfeiss
Šī ir saknes saskarne visam kolekcijas ietvaram. Kolekcijas saskarne paplašina atkārtojamo interfeisu. Tāpēc visas saskarnes un klases īsteno šo saskarni. Šīs saskarnes galvenā funkcija ir nodrošināt kolekcijām iteratoru. Tāpēc šajā saskarnē ir tikai viena abstrakta metode, kas ir iterators. Tas atgriež
Iterator iterator();>
2. Kolekcijas saskarne
Šis interfeiss paplašina atkārtojamo saskarni, un to ievieš visas kolekcijas sistēmas klases. Šajā interfeisā ir ietvertas visas pamatmetodes, kas ir katrai kolekcijai, piemēram, datu pievienošana kolekcijai, datu noņemšana, datu dzēšana utt. Visas šīs metodes ir ieviestas šajā saskarnē, jo šīs metodes tiek ieviestas visās klasēs neatkarīgi no to stila. īstenošanai. Turklāt šo metožu izmantošana šajā saskarnē nodrošina, ka metožu nosaukumi ir universāli visām kolekcijām. Tāpēc īsumā mēs varam teikt, ka šī saskarne veido pamatu, uz kura tiek īstenotas kolekcijas klases.
3. Saraksta interfeiss
Šī ir kolekcijas saskarnes bērnu saskarne. Šī saskarne ir paredzēta saraksta tipa datiem, kuros varam glabāt visas sakārtotās objektu kolekcijas. Tas arī ļauj tajā atrasties dublētiem datiem. Šo saraksta saskarni ievieš dažādas klases, piemēram, ArrayList, Vector, Stack utt. Tā kā visas apakšklases īsteno sarakstu, mēs varam izveidot saraksta objektu ar jebkuru no šīm klasēm.
Piemēram:
List al = new ArrayList (); List ll = new LinkedList (); List v = new Vector (); Where T is the type of the object>
Klases, kas ievieš saskarni List, ir šādas:
i). ArrayList
ArrayList nodrošina mums dinamiskus masīvus Java. Tomēr tas var būt lēnāks nekā standarta masīvi, taču tas var būt noderīgs programmās, kurās ir nepieciešams daudz manipulēt ar masīvu. ArrayList lielums tiek automātiski palielināts, ja kolekcija palielinās vai samazinās, ja objekti tiek izņemti no kolekcijas. Java ArrayList ļauj mums nejauši piekļūt sarakstam. ArrayList nevar izmantot iesaiņojuma klase šādiem gadījumiem.
Sapratīsim ArrayList ar šādu piemēru:
Java
// Java program to demonstrate the> // working of ArrayList> import> java.io.*;> import> java.util.*;> class> GFG {> >// Main Method> >public> static> void> main(String[] args)> >{> >// Declaring the ArrayList with> >// initial size n> >ArrayList al =>new> ArrayList();> >// Appending new elements at> >// the end of the list> >for> (>int> i =>1>; i <=>5>; i++)> >al.add(i);> >// Printing elements> >System.out.println(al);> >// Remove element at index 3> >al.remove(>3>);> >// Displaying the ArrayList> >// after deletion> >System.out.println(al);> >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(al.get(i) + ' '); } }> |
>
>Izvade
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
ii). LinkedList
LinkedList klase ir implementācija Sapratīsim LinkedList ar šādu piemēru:
Java
// Java program to demonstrate the> // working of LinkedList> import> java.io.*;> import> java.util.*;> class> GFG {> >// Main Method> >public> static> void> main(String[] args)> >{> >// Declaring the LinkedList> >LinkedList ll =>new> LinkedList();> >// Appending new elements at> >// the end of the list> >for> (>int> i =>1>; i <=>5>; i++)> >ll.add(i);> >// Printing elements> >System.out.println(ll);> >// Remove element at index 3> >ll.remove(>3>);> >// Displaying the List> >// after deletion> >System.out.println(ll);> >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(ll.get(i) + ' '); } }> |
>
>Izvade
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
iii). Vektors
Vektors nodrošina mums dinamiskus masīvus Java. Tomēr tas var būt lēnāks nekā standarta masīvi, taču tas var būt noderīgs programmās, kurās ir nepieciešams daudz manipulēt ar masīvu. Īstenošanas ziņā tas ir identisks ArrayList. Tomēr galvenā atšķirība starp vektoru un ArrayList ir tā, ka vektors ir sinhronizēts un ArrayList nav sinhronizēts.
Sapratīsim vektoru ar piemēru:
Java
// Java program to demonstrate the> // working of Vector> import> java.io.*;> import> java.util.*;> class> GFG {> >// Main Method> >public> static> void> main(String[] args)> >{> >// Declaring the Vector> >Vector v =>new> Vector();> >// Appending new elements at> >// the end of the list> >for> (>int> i =>1>; i <=>5>; i++)> >v.add(i);> >// Printing elements> >System.out.println(v);> >// Remove element at index 3> >v.remove(>3>);> >// Displaying the Vector> >// after deletion> >System.out.println(v);> >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(v.get(i) + ' '); } }> |
>
>Izvade
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
iv). Kaudze
Stack klases modeļus un ieviešpēdējais iekšā-pirmais ārā. Papildus pamata push un pop operācijām klase nodrošina vēl trīs tukšas, meklēšanas un palūrēšanas funkcijas. Klasi var saukt arī par Vector apakšklasi.
Sapratīsim kaudzi ar piemēru:
Java
// Java program to demonstrate the> // working of a stack> import> java.util.*;> public> class> GFG {> >// Main Method> >public> static> void> main(String args[])> >{> >Stack stack =>new> Stack();> >stack.push(>'Geeks'>);> >stack.push(>'For'>);> >stack.push(>'Geeks'>);> >stack.push(>'Geeks'>);> >// Iterator for the stack> >Iterator itr = stack.iterator();> >// Printing the stack> >while> (itr.hasNext()) {> >System.out.print(itr.next() +>' '>);> >}> >System.out.println();> >stack.pop();> >// Iterator for the stack> >itr = stack.iterator();> >// Printing the stack> >while> (itr.hasNext()) {> >System.out.print(itr.next() +>' '>);> >}> >}> }> |
>
>Izvade
Geeks For Geeks Geeks Geeks For Geeks>
Piezīme: Stack ir Vector apakšklase un mantotā klase. Tas ir drošs pret vītni, kas var būt virs galvas vidē, kur vītnes drošība nav nepieciešama. Ir jāizmanto alternatīva Stack ArrayDequeue kas nav droša pavedienam un ir ātrāka masīva ieviešana.
4. Rindas interfeiss
Kā norāda nosaukums, rindas interfeiss saglabā FIFO (First In First Out) secību, kas ir līdzīga reālās rindas rindai. Šī saskarne ir paredzēta visu to elementu glabāšanai, kuriem ir nozīme elementu secībai. Piemēram, ikreiz, kad mēģinām rezervēt biļeti, biļetes tiek pārdotas rindas kārtībā. Tāpēc biļeti saņem persona, kuras pieprasījums rindā ierodas pirmais. Ir dažādas klases, piemēram PriorityQueue , ArrayDeque uc Tā kā visas šīs apakšklases realizē rindu, mēs varam izveidot rindas objektu ar jebkuru no šīm klasēm.
Piemēram:
Queue pq = new PriorityQueue (); Queue ad = new ArrayDeque (); Where T is the type of the object.>
Visbiežāk izmantotā rindas saskarnes ieviešana ir PriorityQueue.
Prioritātes rinda
PriorityQueue tiek izmantota, ja objekti ir jāapstrādā, pamatojoties uz prioritāti. Ir zināms, ka rinda notiek pēc algoritma First-In-First-Out, bet dažreiz rindas elementi ir jāapstrādā atbilstoši prioritātei un šajos gadījumos tiek izmantota šī klase. PriorityQueue ir balstīta uz prioritāšu kaudzi. Prioritārās rindas elementi tiek sakārtoti pēc dabiskās secības vai ar a Salīdzinātājs nodrošina rindas būvniecības laikā, atkarībā no tā, kurš konstruktors tiek izmantots.
Izpratīsim prioritāro rindu ar piemēru:
Java
// Java program to demonstrate the working of> // priority queue in Java> import> java.util.*;> class> GfG {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating empty priority queue> >PriorityQueue pQueue> >=>new> PriorityQueue();> >// Adding items to the pQueue using add()> >pQueue.add(>10>);> >pQueue.add(>20>);> >pQueue.add(>15>);> >// Printing the top element of PriorityQueue> >System.out.println(pQueue.peek());> >// Printing the top element and removing it> >// from the PriorityQueue container> >System.out.println(pQueue.poll());> >// Printing the top element again> >System.out.println(pQueue.peek());> >}> }> |
>
>Izvade
10 10 15>
5. Un interfeiss
Šī ir ļoti neliela variācija Piemēram:
Deque ad = new ArrayDeque (); Where T is the type of the object.>
Klase, kas ievieš deque interfeisu, ir ArrayDeque.
ArrayDeque
ArrayDeque klase, kas ir ieviesta kolekcijas sistēmā, sniedz mums veidu, kā piemērot maināmu masīvu. Šis ir īpašs masīvs, kas aug un ļauj lietotājiem pievienot vai noņemt elementu no abām rindas pusēm. Masīvu deques nav jaudas ierobežojumu, un tie pieaug, ja nepieciešams, lai atbalstītu izmantošanu.
Sapratīsim ArrayDeque ar piemēru:
Java
// Java program to demonstrate the> // ArrayDeque class in Java> import> java.util.*;> public> class> ArrayDequeDemo {> >public> static> void> main(String[] args)> >{> >// Initializing an deque> >ArrayDeque de_que> >=>new> ArrayDeque(>10>);> >// add() method to insert> >de_que.add(>10>);> >de_que.add(>20>);> >de_que.add(>30>);> >de_que.add(>40>);> >de_que.add(>50>);> >System.out.println(de_que);> >// clear() method> >de_que.clear();> >// addFirst() method to insert the> >// elements at the head> >de_que.addFirst(>564>);> >de_que.addFirst(>291>);> >// addLast() method to insert the> >// elements at the tail> >de_que.addLast(>24>);> >de_que.addLast(>14>);> >System.out.println(de_que);> >}> }> |
>
>Izvade
[10, 20, 30, 40, 50] [291, 564, 24, 14]>
6. Iestatīt interfeisu
Kopa ir nesakārtota objektu kolekcija, kurā nevar saglabāt dublētās vērtības. Šo kolekciju izmanto, ja vēlamies izvairīties no objektu dublēšanās un vēlamies glabāt tikai unikālos objektus. Šo kopas saskarni ievieš dažādas klases, piemēram, HashSet, TreeSet, LinkedHashSet utt. Tā kā visas apakšklases īsteno kopu, mēs varam izveidot kopas objektu ar jebkuru no šīm klasēm.
Piemēram:
Set hs = new HashSet (); Set lhs = new LinkedHashSet (); Set ts = new TreeSet (); Where T is the type of the object.>
Tālāk ir norādītas klases, kas ievieš saskarni Set:
i). HashSet
HashSet klase ir hash tabulas datu struktūras ieviešana. Objekti, kurus ievietojam HashSet, negarantē, ka tie tiks ievietoti tādā pašā secībā. Objekti tiek ievietoti, pamatojoties uz to jaucējkodu. Šī klase ļauj arī ievietot NULL elementus. Sapratīsim HashSet ar piemēru:
Java
// Java program to demonstrate the> // working of a HashSet> import> java.util.*;> public> class> HashSetDemo {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating HashSet and> >// adding elements> >HashSet hs =>new> HashSet();> >hs.add(>'Geeks'>);> >hs.add(>'For'>);> >hs.add(>'Geeks'>);> >hs.add(>'Is'>);> >hs.add(>'Very helpful'>);> >// Traversing elements> >Iterator itr = hs.iterator();> >while> (itr.hasNext()) {> >System.out.println(itr.next());> >}> >}> }> |
>
>Izvade
Very helpful Geeks For Is>
ii). LinkedHashSet
LinkedHashSet ir ļoti līdzīgs HashSet. Atšķirība ir tāda, ka datu glabāšanai tiek izmantots divkārši saistīts saraksts un tiek saglabāta elementu secība.
Sapratīsim LinkedHashSet ar piemēru:
Java
// Java program to demonstrate the> // working of a LinkedHashSet> import> java.util.*;> public> class> LinkedHashSetDemo {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating LinkedHashSet and> >// adding elements> >LinkedHashSet lhs> >=>new> LinkedHashSet();> >lhs.add(>'Geeks'>);> >lhs.add(>'For'>);> >lhs.add(>'Geeks'>);> >lhs.add(>'Is'>);> >lhs.add(>'Very helpful'>);> >// Traversing elements> >Iterator itr = lhs.iterator();> >while> (itr.hasNext()) {> >System.out.println(itr.next());> >}> >}> }> |
>
>Izvade
Geeks For Is Very helpful>
7. Sakārtots komplekta interfeiss
Šī saskarne ir ļoti līdzīga iestatītajai saskarnei. Vienīgā atšķirība ir tā, ka šai saskarnei ir papildu metodes, kas uztur elementu secību. Šķirotās kopas saskarne paplašina kopas saskarni un tiek izmantota, lai apstrādātu datus, kas ir jākārto. Klase, kas ievieš šo saskarni, ir TreeSet. Tā kā šī klase īsteno SortedSet, mēs varam izveidot SortedSet objektu ar šo klasi.
Piemēram:
SortedSet ts = new TreeSet (); Where T is the type of the object.>
Klase, kas ievieš šķiroto kopu saskarni, ir TreeSet.
TreeSet
TreeSet klase glabāšanai izmanto koku. Elementu secību uztur kopa, izmantojot to dabisko secību neatkarīgi no tā, vai ir nodrošināts precīzs salīdzinātājs. Tam ir jāatbilst vienlīdzīgam, lai pareizi ieviestu saskarni Set. To var pasūtīt arī Comparator, kas tiek nodrošināts noteiktā izveides laikā, atkarībā no izmantotā konstruktora.
Sapratīsim TreeSet ar piemēru:
Java
// Java program to demonstrate the> // working of a TreeSet> import> java.util.*;> public> class> TreeSetDemo {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating TreeSet and> >// adding elements> >TreeSet ts =>new> TreeSet();> >ts.add(>'Geeks'>);> >ts.add(>'For'>);> >ts.add(>'Geeks'>);> >ts.add(>'Is'>);> >ts.add(>'Very helpful'>);> >// Traversing elements> >Iterator itr = ts.iterator();> >while> (itr.hasNext()) {> >System.out.println(itr.next());> >}> >}> }> |
>
>Izvade
For Geeks Is Very helpful>
8. Kartes interfeiss
Karte ir datu struktūra, kas atbalsta atslēgas-vērtības pāri datu kartēšanai. Šī saskarne neatbalsta dublētās atslēgas, jo vienai un tai pašai atslēgai nevar būt vairākas kartēšanas, taču tā pieļauj vērtību dublikātus dažādās atslēgās. Karte ir noderīga, ja ir dati un mēs vēlamies veikt darbības, pamatojoties uz atslēgu. Šo kartes saskarni ievieš dažādas klases, piemēram HashMap , TreeMap uc Tā kā visas apakšklases īsteno karti, mēs varam izveidot kartes objektu ar jebkuru no šīm klasēm.
Piemēram:
Map hm = new HashMap (); Map tm = new TreeMap (); Where T is the type of the object.>
Bieži izmantotā kartes saskarnes ieviešana ir HashMap.
HashMap
HashMap nodrošina Java Map interfeisa pamata ieviešanu. Tas saglabā datus (atslēga, vērtība) pāros. Lai piekļūtu vērtībai HashMap, mums ir jāzina tās atslēga. HashMap izmanto paņēmienu, ko sauc par jaukšanu. Jaukšana ir paņēmiens lielas virknes pārvēršanai par mazu virkni, kas apzīmē vienu un to pašu virkni, lai indeksēšanas un meklēšanas darbības būtu ātrākas. HashSet izmanto arī HashMap iekšēji.
Sapratīsim HashMap ar piemēru:
Java
// Java program to demonstrate the> // working of a HashMap> import> java.util.*;> public> class> HashMapDemo {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating HashMap and> >// adding elements> >HashMap hm> >=>new> HashMap();> >hm.put(>1>,>'Geeks'>);> >hm.put(>2>,>'For'>);> >hm.put(>3>,>'Geeks'>);> >// Finding the value for a key> >System.out.println(>'Value for 1 is '> + hm.get(>1>));> >// Traversing through the HashMap> >for> (Map.Entry e : hm.entrySet())> >System.out.println(e.getKey() +>' '> >+ e.getValue());> >}> }> |
>
>Izvade
Value for 1 is Geeks 1 Geeks 2 For 3 Geeks>