Elke groep individuele objecten die als een enkele eenheid wordt weergegeven, staat bekend als een Java-verzameling van objecten. In Java is er een apart raamwerk met de naam Collectiekader is gedefinieerd in JDK 1.2, dat alle Java Collection Classes en Interface bevat.
In Java is de collectie-interface ( java.util.Collectie ) en kaartinterface ( java.util.Map ) zijn de twee belangrijkste rootinterfaces van Java-verzamelingsklassen.
Wat u moet leren in Java-collecties?
- Lijstinterface
- Klasse abstracte lijst
- Abstracte opeenvolgende lijstklasse
- Array-lijst
- Vectorklasse
- Stapel klasse
- LinkedList-klasse
- Wachtrij-interface
- Wachtrijinterface blokkeren
- AbstractQueue-klasse
- PriorityQueue-klasse
- PriorityBlockingQueue-klasse
- ConcurrentLinkedQueue-klasse
- ArrayBlockingQueue-klasse
- DelayQueue-klasse
- LinkedBlockingQueue-klasse
- LinkedTransferQueue
- En de interface
- BlockingDeque-interface
- ConcurrentLinkedDeque-klasse
- ArrayDeque-klasse
- Interface instellen
- Abstracte ingestelde klasse
- CopyOnWriteArraySet-klasse
- EnumSet-klasse
- ConcurrentHashMap-klasse
- HashSet-klasse
- LinkedHashSet-klasse
- SortedSet-interface
- Navigeerbare set-interface
- BoomSet
- ConcurrentSkipListSet-klasse
- Kaartinterface
- SortedMap-interface
- Navigeerbare kaartinterface
- ConcurrentMap-interface
- TreeMap-klasse
- AbstractMap-klasse
- ConcurrentHashMap-klasse
- EnumMap-klasse
- HashMap-klasse
- IdentityHashMap-klasse
- LinkedHashMap-klasse
- HashTable-klasse
- Eigenschappen klasse
- Andere belangrijke concepten
- Hoe HashMap naar ArrayList te converteren
- Selecteer willekeurig items uit een lijst
- Hoe u alle items uit een verzameling aan een ArrayList kunt toevoegen
- Conversie van Java-kaarten naar lijst
- Conversie van array naar arraylijst
- ArrayList naar array-conversie
- Verschillen tussen Array en ArrayList
Wat is een raamwerk in Java?
Een raamwerk is een reeks klassen en interfaces die een kant-en-klare architectuur bieden. Om een nieuwe feature of klasse te implementeren, is het niet nodig om een raamwerk te definiëren. Een optimaal objectgeoriënteerd ontwerp omvat echter altijd een raamwerk met een verzameling klassen, zodat alle klassen dezelfde soort taak uitvoeren.
Behoefte aan een afzonderlijk verzamelframework in Java
Voordat het Collection Framework (of vóór JDK 1.2) werd geïntroduceerd, waren de standaardmethoden voor het groeperen van Java-objecten (of collecties) Arrays of Vectoren , of Hashtabellen . Al deze collecties hadden geen gemeenschappelijke interface. Hoewel het hoofddoel van alle collecties hetzelfde is, werd de implementatie van al deze collecties daarom onafhankelijk gedefinieerd en bestond er geen onderlinge correlatie. En het is ook erg moeilijk voor de gebruikers om al de verschillende te onthouden methoden , syntaxis, en constructeurs aanwezig in elke collectieklasse.
Laten we dit begrijpen met een voorbeeld van het toevoegen van een element aan een hashtabel en een vector.
voor loop bash
Voorbeeld:
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()> >}> }> |
>
>Uitvoer
1 1 geeks>
Zoals we kunnen zien, implementeert geen van deze collecties (Array, Vector of Hashtable) een standaard interface voor ledentoegang. Het was erg moeilijk voor programmeurs om algoritmen te schrijven die voor allerlei soorten collecties kunnen werken. Een ander nadeel is dat de meeste ‘Vector’-methoden definitief zijn, wat betekent dat we de klasse ’Vector’ niet kunnen uitbreiden om een soortgelijk soort Collection te implementeren. Daarom besloten Java-ontwikkelaars om met een gemeenschappelijke interface te komen om de bovengenoemde problemen aan te pakken en introduceerden ze het Collection Framework in JDK 1.2, waarin zowel oudere vectoren als hashtabellen werden aangepast om te voldoen aan het Collection Framework.
Voordelen van het Java Collection Framework
Omdat het ontbreken van een verzamelraamwerk aanleiding gaf tot de bovengenoemde reeks nadelen, volgen hier de voordelen van het verzamelraamwerk.
- Consistente API: De API heeft een basisset van interfaces zoals Verzameling , Set , Lijst , of Kaart , hebben alle klassen (ArrayList, LinkedList, Vector, enz.) die deze interfaces implementeren sommige gemeenschappelijke reeks methoden.
- Vermindert de programmeerinspanning: Een programmeur hoeft zich geen zorgen te maken over het ontwerp van de collectie, maar kan zich concentreren op het beste gebruik ervan in zijn programma. Daarom is het basisconcept van objectgeoriënteerd programmeren (dat wil zeggen) abstractie met succes geïmplementeerd.
- Verhoogt de programmasnelheid en -kwaliteit: Verhoogt de prestaties door hoogwaardige implementaties van nuttige datastructuren en algoritmen te bieden, omdat de programmeur in dit geval niet hoeft te denken aan de beste implementatie van een specifieke datastructuur. Hij kan eenvoudigweg de beste implementatie gebruiken om de prestaties van zijn algoritme/programma drastisch te verbeteren.
Hiërarchie van het verzamelframework in Java
Het hulpprogrammapakket (java.util) bevat alle klassen en interfaces die vereist zijn door het verzamelframework. Het verzamelingsframework bevat een interface die een itereerbare interface wordt genoemd en waarmee de iterator door alle verzamelingen kan itereren. Deze interface wordt uitgebreid met de hoofdcollectie-interface die fungeert als root voor het collectieframework. Alle collecties breiden deze collectie-interface uit, waardoor de eigenschappen van de iterator en de methoden van deze interface worden uitgebreid. De volgende afbeelding illustreert de hiërarchie van het verzamelraamwerk.
Voordat we de verschillende componenten in het bovenstaande raamwerk begrijpen, moeten we eerst een klasse en een interface begrijpen.
- Klas : Een klasse is een door de gebruiker gedefinieerde blauwdruk of prototype waaruit objecten worden gemaakt. Het vertegenwoordigt de reeks eigenschappen of methoden die gemeenschappelijk zijn voor alle objecten van één type.
- Koppel : Net als een klasse kan een interface methoden en variabelen hebben, maar de methoden die in een interface worden gedeclareerd, zijn standaard abstract (alleen handtekening van de methode, niemand). Interfaces specificeren wat een klasse moet doen en niet hoe. Het is de blauwdruk van de klas.
Methoden van de collectie-interface
Deze interface bevat verschillende methoden die direct kunnen worden gebruikt door alle collecties die deze interface implementeren. Zij zijn:
| Methode | Beschrijving |
|---|---|
| toevoegen(Object) | Deze methode wordt gebruikt om een object aan de collectie toe te voegen. |
| addAll(verzameling c) | Deze methode voegt alle elementen in de gegeven verzameling toe aan deze verzameling. |
| duidelijk() | Met deze methode worden alle elementen uit deze verzameling verwijderd. |
| bevat(Object o) | Deze methode retourneert true als de verzameling het opgegeven element bevat. |
| bevatAlles(Verzameling c) | Deze methode retourneert true als de verzameling alle elementen in de gegeven verzameling bevat. |
| is gelijk aan(Object o) | Deze methode vergelijkt het opgegeven object met deze verzameling op gelijkheid. |
| hashCode() | Deze methode wordt gebruikt om de hashcodewaarde voor deze verzameling te retourneren. |
| is leeg() | Deze methode retourneert true als deze verzameling geen elementen bevat. |
| iterator() | Deze methode retourneert een iterator over de elementen in deze verzameling. |
| maximaal() | Deze methode wordt gebruikt om de maximale waarde in de verzameling te retourneren. |
| parallelStream() | Deze methode retourneert een parallelle stream met deze verzameling als bron. |
| verwijder(Object o) | Deze methode wordt gebruikt om het gegeven object uit de collectie te verwijderen. Als er dubbele waarden zijn, verwijdert deze methode de eerste keer dat het object voorkomt. |
| removeAll(Verzameling c) | Deze methode wordt gebruikt om alle objecten genoemd in de betreffende collectie uit de collectie te verwijderen. |
| removeIf(Predikaatfilter) | Deze methode wordt gebruikt om alle elementen van deze verzameling te verwijderen die aan het gegeven voldoen predikaat . |
| behoudenAlles(Verzameling c) | Deze methode wordt gebruikt om alleen de elementen in deze verzameling te behouden die zich in de opgegeven verzameling bevinden. |
| maat() | Deze methode wordt gebruikt om het aantal elementen in de verzameling te retourneren. |
| splitter() | Deze methode wordt gebruikt om een Splitser over de elementen in deze collectie. |
| stroom() | Deze methode wordt gebruikt om een sequentiële stroom te retourneren met deze verzameling als bron. |
| toArray() | Deze methode wordt gebruikt om een array terug te geven die alle elementen in deze verzameling bevat. |
Interfaces die de Java Collections Interface uitbreiden
Het verzamelframework bevat meerdere interfaces waarbij elke interface wordt gebruikt om een specifiek type gegevens op te slaan. Hieronder volgen de interfaces die in het raamwerk aanwezig zijn.
1. Itereerbare interface
Dit is de hoofdinterface voor het gehele verzamelingsframework. De verzamelingsinterface breidt de itereerbare interface uit. Daarom implementeren alle interfaces en klassen inherent deze interface. De belangrijkste functionaliteit van deze interface is het bieden van een iterator voor de collecties. Daarom bevat deze interface slechts één abstracte methode, namelijk de iterator. Het retourneert de
Iterator iterator();>
2. Collectie-interface
Deze interface breidt de iterabele interface uit en wordt geïmplementeerd door alle klassen in het verzamelingsframework. Deze interface bevat alle basismethoden die elke verzameling heeft, zoals het toevoegen van gegevens aan de verzameling, het verwijderen van de gegevens, het wissen van de gegevens, enz. Al deze methoden zijn in deze interface geïmplementeerd omdat deze methoden door alle klassen worden geïmplementeerd, ongeacht hun stijl. van implementatie. En bovendien zorgt het hebben van deze methoden in deze interface ervoor dat de namen van de methoden universeel zijn voor alle collecties. Daarom kunnen we kort gezegd zeggen dat deze interface een basis bouwt waarop de verzamelingsklassen worden geïmplementeerd.
3. Lijstinterface
Dit is een onderliggende interface van de verzamelingsinterface. Deze interface is bedoeld voor de gegevens van het lijsttype waarin we alle geordende verzamelingen van de objecten kunnen opslaan. Hierdoor kunnen er ook dubbele gegevens in voorkomen. Deze lijstinterface wordt geïmplementeerd door verschillende klassen zoals ArrayList, Vector, Stack, enz. Omdat alle subklassen de lijst implementeren, kunnen we een lijstobject instantiëren met elk van deze klassen.
Bijvoorbeeld:
List al = new ArrayList (); List ll = new LinkedList (); List v = new Vector (); Where T is the type of the object>
De klassen die de List-interface implementeren zijn als volgt:
i). ArrayLijst
ArrayList biedt ons dynamische arrays in Java. Hoewel het langzamer kan zijn dan standaardarrays, kan het nuttig zijn in programma's waarbij veel manipulatie in de array nodig is. De grootte van een ArrayList wordt automatisch vergroot als de verzameling groter of kleiner wordt als de objecten uit de verzameling worden verwijderd. Met Java ArrayList kunnen we willekeurig toegang krijgen tot de lijst. ArrayList kan niet worden gebruikt voor wikkelklasse voor dergelijke gevallen.
Laten we de ArrayList begrijpen met het volgende voorbeeld:
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) + ' '); } }> |
>
>Uitvoer
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
ii). GelinkteLijst
De klasse LinkedList is een implementatie van de Laten we de LinkedList begrijpen met het volgende voorbeeld:
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) + ' '); } }> |
>
>Uitvoer
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
iii). Vector
Een vector biedt ons dynamische arrays in Java. Hoewel het langzamer kan zijn dan standaardarrays, kan het nuttig zijn in programma's waarbij veel manipulatie in de array nodig is. Dit is qua implementatie identiek aan ArrayList. Het belangrijkste verschil tussen een vector en een ArrayList is echter dat een vector gesynchroniseerd is en een ArrayList niet-gesynchroniseerd.
Laten we de vector begrijpen met een voorbeeld:
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) + ' '); } }> |
>
>Uitvoer
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
IV). Stapel
Stapel klassemodellen en implementeert deLaatste erin, eerste eruit. Naast de standaard push- en pop-bewerkingen biedt de klasse nog drie functies leeg, zoeken en kijken. De klasse kan ook de subklasse van Vector worden genoemd.
Laten we de stapel begrijpen met een voorbeeld:
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() +>' '>);> >}> >}> }> |
>
>Uitvoer
Geeks For Geeks Geeks Geeks For Geeks>
Opmerking: Stack is een subklasse van Vector en een oudere klasse. Het is draadveilig, wat zich boven het hoofd kan bevinden in een omgeving waar draadveiligheid niet nodig is. Een alternatief voor Stack is om te gebruiken ArrayDequeue die niet thread-safe is en een snellere array-implementatie heeft.
4. Wachtrij-interface
Zoals de naam al doet vermoeden, handhaaft een wachtrij-interface de FIFO-volgorde (First In First Out), vergelijkbaar met een wachtrij in de echte wereld. Deze interface is bedoeld voor het opslaan van alle elementen waarbij de volgorde van de elementen ertoe doet. Wanneer we bijvoorbeeld een ticket proberen te boeken, worden de tickets verkocht op basis van wie het eerst komt, het eerst maalt. Daarom krijgt de persoon wiens verzoek als eerste in de wachtrij arriveert het ticket. Er zijn verschillende klassen zoals Prioriteits-rij , ArrayDeque , enz. Omdat al deze subklassen de wachtrij implementeren, kunnen we met elk van deze klassen een wachtrijobject instantiëren.
Bijvoorbeeld:
Queue pq = new PriorityQueue (); Queue ad = new ArrayDeque (); Where T is the type of the object.>
De meest gebruikte implementatie van de wachtrij-interface is de PriorityQueue.
Prioriteits-rij
Een PriorityQueue wordt gebruikt wanneer de objecten moeten worden verwerkt op basis van prioriteit. Het is bekend dat een wachtrij het First-In-First-Out-algoritme volgt, maar soms moeten de elementen van de wachtrij worden verwerkt volgens de prioriteit en in deze gevallen wordt deze klasse gebruikt. De PriorityQueue is gebaseerd op de prioriteitsheap. De elementen van de prioriteitswachtrij worden geordend volgens de natuurlijke volgorde, of door a Comparator aangeboden tijdens de bouwtijd van de wachtrij, afhankelijk van welke constructor wordt gebruikt.
Laten we de prioriteitswachtrij begrijpen met een voorbeeld:
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());> >}> }> |
>
>Uitvoer
10 10 15>
5. En de interface
Dit is een zeer kleine variatie op de Bijvoorbeeld:
Deque ad = new ArrayDeque (); Where T is the type of the object.>
De klasse die de deque-interface implementeert is ArrayDeque.
ArrayDeque
De klasse ArrayDeque die in het verzamelingsframework is geïmplementeerd, biedt ons een manier om een aanpasbare array toe te passen. Dit is een speciaal soort array dat groeit en gebruikers in staat stelt een element aan beide kanten van de wachtrij toe te voegen of te verwijderen. Array-deques hebben geen capaciteitsbeperkingen en groeien indien nodig om het gebruik te ondersteunen.
Laten we ArrayDeque begrijpen met een voorbeeld:
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);> >}> }> |
>
>Uitvoer
[10, 20, 30, 40, 50] [291, 564, 24, 14]>
6. Interface instellen
Een set is een ongeordende verzameling objecten waarin dubbele waarden niet kunnen worden opgeslagen. Deze verzameling wordt gebruikt wanneer we het dupliceren van objecten willen vermijden en alleen de unieke objecten willen opslaan. Deze set-interface wordt geïmplementeerd door verschillende klassen zoals HashSet, TreeSet, LinkedHashSet, enz. Omdat alle subklassen de set implementeren, kunnen we een set-object instantiëren met elk van deze klassen.
Bijvoorbeeld:
Set hs = new HashSet (); Set lhs = new LinkedHashSet (); Set ts = new TreeSet (); Where T is the type of the object.>
Hieronder volgen de klassen die de Set-interface implementeren:
i). HashSet
De klasse HashSet is een inherente implementatie van de gegevensstructuur van de hashtabel. De objecten die we in de HashSet invoegen, garanderen niet dat ze in dezelfde volgorde worden ingevoegd. De objecten worden ingevoegd op basis van hun hashcode. Deze klasse maakt ook het invoegen van NULL-elementen mogelijk. Laten we HashSet begrijpen met een voorbeeld:
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());> >}> >}> }> |
>
>Uitvoer
Very helpful Geeks For Is>
ii). GekoppeldeHashSet
Een LinkedHashSet lijkt sterk op een HashSet. Het verschil is dat hierbij een dubbel gekoppelde lijst wordt gebruikt om de gegevens op te slaan en de volgorde van de elementen behouden blijft.
Laten we de LinkedHashSet begrijpen met een voorbeeld:
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());> >}> >}> }> |
>
>Uitvoer
Geeks For Is Very helpful>
7. Gesorteerde set-interface
Deze interface lijkt sterk op de ingestelde interface. Het enige verschil is dat deze interface extra methoden heeft die de volgorde van de elementen behouden. De gesorteerde set-interface breidt de set-interface uit en wordt gebruikt om de gegevens te verwerken die moeten worden gesorteerd. De klasse die deze interface implementeert is TreeSet. Omdat deze klasse de SortedSet implementeert, kunnen we met deze klasse een SortedSet-object instantiëren.
Bijvoorbeeld:
SortedSet ts = new TreeSet (); Where T is the type of the object.>
De klasse die de gesorteerde set-interface implementeert, is TreeSet.
BoomSet
De TreeSet-klasse gebruikt een Tree voor opslag. De volgorde van de elementen wordt gehandhaafd door een set die hun natuurlijke volgorde gebruikt, ongeacht of er al dan niet een expliciete comparator is voorzien. Dit moet consistent zijn met gelijken als het de Set-interface correct wil implementeren. Het kan ook worden besteld via een Comparator die op een bepaald aanmaaktijdstip wordt geleverd, afhankelijk van welke constructor wordt gebruikt.
Laten we TreeSet begrijpen met een voorbeeld:
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());> >}> >}> }> |
>
>Uitvoer
For Geeks Is Very helpful>
8. Kaartinterface
Een kaart is een gegevensstructuur die het sleutel-waardepaar ondersteunt voor het in kaart brengen van de gegevens. Deze interface ondersteunt geen dubbele sleutels omdat dezelfde sleutel niet meerdere toewijzingen kan hebben. Wel zijn dubbele waarden in verschillende sleutels toegestaan. Een kaart is handig als er gegevens zijn en we op basis van de sleutel bewerkingen willen uitvoeren. Deze kaartinterface wordt geïmplementeerd door verschillende klassen, zoals Hash kaart , Boomkaart , enz. Omdat alle subklassen de kaart implementeren, kunnen we met elk van deze klassen een kaartobject instantiëren.
Bijvoorbeeld:
Map hm = new HashMap (); Map tm = new TreeMap (); Where T is the type of the object.>
De veelgebruikte implementatie van een kaartinterface is een HashMap.
Hash kaart
HashMap biedt de basisimplementatie van de Map-interface van Java. Het slaat de gegevens op in (sleutel, waarde) paren. Om toegang te krijgen tot een waarde in een HashMap, moeten we de sleutel ervan kennen. HashMap maakt gebruik van een techniek genaamd Hashing. Hashing is een techniek waarbij een grote String wordt geconverteerd naar een kleine String die dezelfde String vertegenwoordigt, zodat de indexerings- en zoekbewerkingen sneller verlopen. HashSet maakt ook intern gebruik van HashMap.
Laten we de HashMap begrijpen met een voorbeeld:
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());> >}> }> |
>
>Uitvoer
Value for 1 is Geeks 1 Geeks 2 For 3 Geeks>