1. Java-collectieframework
2. Hiërarchie van het verzamelkader
3. Verzamelinterface
4. Iterator-interface

De Verzameling op Java is een raamwerk dat een architectuur biedt om de groep objecten op te slaan en te manipuleren.

Java-collecties kunnen alle bewerkingen uitvoeren die u op gegevens uitvoert, zoals zoeken, sorteren, invoegen, manipuleren en verwijderen.

Java Collection betekent een enkele eenheid objecten. Het Java Collection-framework biedt veel interfaces (Set, List, Queue, Deque) en klassen ( ArrayLijst , Vector, GelinkteLijst , Prioriteits-rij , HashSet, LinkedHashSet, TreeSet).

Wat is verzamelen op Java

Een verzameling vertegenwoordigt een enkele eenheid objecten, dat wil zeggen een groep.

Wat is een raamwerk in Java

• Het biedt kant-en-klare architectuur.
• Het vertegenwoordigt een reeks klassen en interfaces.
• Het is optioneel.

Wat is het verzamelraamwerk

Het Collection-framework vertegenwoordigt een uniforme architectuur voor het opslaan en manipuleren van een groep objecten. Het heeft:

1. Interfaces en de implementaties ervan, dat wil zeggen klassen
2. Algoritme

• Op welke twee manieren kunnen de elementen van een verzameling worden herhaald?
• Wat is het verschil tussen ArrayList- en LinkedList-klassen in het verzamelframework?
• Wat is het verschil tussen ArrayList- en Vector-klassen in het verzamelframework?
• Wat is het verschil tussen HashSet- en HashMap-klassen in het verzamelframework?
• Wat is het verschil tussen HashMap en Hashtable-klasse?
• Wat is het verschil tussen de Iterator- en Enumeration-interface in het verzamelframework?
• Hoe kunnen we de elementen van een object sorteren? Wat is het verschil tussen Comparable- en Comparator-interfaces?
• Wat betekent de hashcode() methode?
• Wat is het verschil tussen Java-collectie en Java-collecties?

Hiërarchie van het verzamelkader

Laten we eens kijken naar de hiërarchie van het collectiekader. De java.util pakket bevat alle klassen En interfaces voor het Collectiekader.

Interface voor verzamelmethoden

Er zijn veel methoden gedeclareerd in de verzamelingsinterface. Ze zijn als volgt:

Iterator-interface

Methoden van de Iterator-interface

Er zijn slechts drie methoden in de Iterator-interface. Zij zijn:

Itereerbare interface

De iterabele interface is de hoofdinterface voor alle verzamelingsklassen. De Collection-interface breidt de Iterable-interface uit en daarom implementeren alle subklassen van de Collection-interface ook de Iterable-interface.

Het bevat slechts één abstracte methode. d.w.z.,

 Iterator iterator() 

Het retourneert de iterator over de elementen van het type T.

voor loop bash

Collectie-interface

De Collection-interface is de interface die door alle klassen in het collection-framework wordt geïmplementeerd. Het declareert de methoden die elke verzameling zal hebben. Met andere woorden, we kunnen zeggen dat de collectie-interface de basis vormt waarop het collectieframework berust.

Enkele van de methoden van de Collection-interface zijn Boolean add ( Object obj), Boolean addAll ( Collection c), void clear(), etc. die worden geïmplementeerd door alle subklassen van de Collection-interface.

Lijstinterface

De lijstinterface is de onderliggende interface van de collectie-interface. Het verhindert een gegevensstructuur van het lijsttype waarin we de geordende verzameling objecten kunnen opslaan. Het kan dubbele waarden bevatten.

De lijstinterface wordt geïmplementeerd door de klassen ArrayList, LinkedList, Vector en Stack.

Om de Lijst-interface te instantiëren, moeten we het volgende gebruiken:

 List list1= new ArrayList(); List list2 = new LinkedList(); List list3 = new Vector(); List list4 = new Stack(); 

Er zijn verschillende methoden in de Lijstinterface die kunnen worden gebruikt om de elementen uit de lijst in te voegen, te verwijderen en te openen.

De klassen die de List-interface implementeren, worden hieronder gegeven.

ArrayLijst

De klasse ArrayList implementeert de List-interface. Het maakt gebruik van een dynamische array om het dubbele element van verschillende gegevenstypen op te slaan. De klasse ArrayList handhaaft de invoegvolgorde en is niet-gesynchroniseerd. De elementen die zijn opgeslagen in de klasse ArrayList zijn willekeurig toegankelijk. Beschouw het volgende voorbeeld.

 import java.util.*; class TestJavaCollection1{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Ravi');//Adding object in arraylist list.add('Vijay'); list.add('Ravi'); list.add('Ajay'); //Traversing list through Iterator Iterator itr=list.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Uitgang:

 Ravi Vijay Ravi Ajay 

GelinkteLijst

LinkedList implementeert de Collection-interface. Het gebruikt intern een dubbel gekoppelde lijst om de elementen op te slaan. Het kan de dubbele elementen opslaan. Het handhaaft de invoegvolgorde en is niet gesynchroniseerd. In LinkedList is de manipulatie snel omdat er geen verschuiving nodig is.

Beschouw het volgende voorbeeld.

 import java.util.*; public class TestJavaCollection2{ public static void main(String args[]){ LinkedList al=new LinkedList(); al.add('Ravi'); al.add('Vijay'); al.add('Ravi'); al.add('Ajay'); Iterator itr=al.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Uitgang:

 Ravi Vijay Ravi Ajay 

Vector

Vector gebruikt een dynamische array om de gegevenselementen op te slaan. Het is vergelijkbaar met ArrayList. Het is echter gesynchroniseerd en bevat veel methoden die geen deel uitmaken van het Collection-framework.

Beschouw het volgende voorbeeld.

 import java.util.*; public class TestJavaCollection3{ public static void main(String args[]){ Vector v=new Vector(); v.add('Ayush'); v.add('Amit'); v.add('Ashish'); v.add('Garima'); Iterator itr=v.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Uitgang:

 Ayush Amit Ashish Garima 

Stapel

De stapel is de subklasse van Vector. Het implementeert de last-in-first-out-gegevensstructuur, dat wil zeggen Stack. De stapel bevat alle methoden van de klasse Vector en biedt ook de bijbehorende methoden, zoals boolean push(), boolean peek(), boolean push(object o), die de eigenschappen ervan definieert.

Beschouw het volgende voorbeeld.

 import java.util.*; public class TestJavaCollection4{ public static void main(String args[]){ Stack stack = new Stack(); stack.push('Ayush'); stack.push('Garvit'); stack.push('Amit'); stack.push('Ashish'); stack.push('Garima'); stack.pop(); Iterator itr=stack.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Uitgang:

 Ayush Garvit Amit Ashish 

Wachtrij-interface

De wachtrij-interface handhaaft de first-in-first-out-volgorde. Het kan worden gedefinieerd als een geordende lijst die wordt gebruikt om de elementen vast te houden die op het punt staan ​​te worden verwerkt. Er zijn verschillende klassen zoals PriorityQueue, Deque en ArrayDeque die de Queue-interface implementeren.

Wachtrijinterface kan worden geïnstantieerd als:

 Queue q1 = new PriorityQueue(); Queue q2 = new ArrayDeque(); 

Er zijn verschillende klassen die de Queue-interface implementeren, waarvan sommige hieronder worden gegeven.

Prioriteits-rij

De PriorityQueue-klasse implementeert de Queue-interface. Het bevat de elementen of objecten die volgens hun prioriteiten moeten worden verwerkt. PriorityQueue staat niet toe dat null-waarden in de wachtrij worden opgeslagen.

Beschouw het volgende voorbeeld.

 import java.util.*; public class TestJavaCollection5{ public static void main(String args[]){ PriorityQueue queue=new PriorityQueue(); queue.add('Amit Sharma'); queue.add('Vijay Raj'); queue.add('JaiShankar'); queue.add('Raj'); System.out.println('head:'+queue.element()); System.out.println('head:'+queue.peek()); System.out.println('iterating the queue elements:'); Iterator itr=queue.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } queue.remove(); queue.poll(); System.out.println('after removing two elements:'); Iterator itr2=queue.iterator(); while(itr2.hasNext()){ System.out.println(itr2.next()); } } } 

Uitgang:

 head:Amit Sharma head:Amit Sharma iterating the queue elements: Amit Sharma Raj JaiShankar Vijay Raj after removing two elements: Raj Vijay Raj 

En de interface

Deque-interface breidt de wachtrij-interface uit. In Deque kunnen we de elementen vanaf beide zijden verwijderen en toevoegen. Deque staat voor een wachtrij met twee uiteinden, waardoor we de bewerkingen aan beide uiteinden kunnen uitvoeren.

Deque kan worden geïnstantieerd als:

 Deque d = new ArrayDeque(); 

ArrayDeque

De klasse ArrayDeque implementeert de Deque-interface. Het vergemakkelijkt ons om de Deque te gebruiken. In tegenstelling tot de wachtrij kunnen we de elementen aan beide uiteinden toevoegen of verwijderen.

ArrayDeque is sneller dan ArrayList en Stack en kent geen capaciteitsbeperkingen.

Beschouw het volgende voorbeeld.

 import java.util.*; public class TestJavaCollection6{ public static void main(String[] args) { //Creating Deque and adding elements Deque deque = new ArrayDeque(); deque.add('Gautam'); deque.add('Karan'); deque.add('Ajay'); //Traversing elements for (String str : deque) { System.out.println(str); } } } 

Uitgang:

 Gautam Karan Ajay 

Interface instellen

Set Interface in Java is aanwezig in het java.util-pakket. Het breidt de collectie-interface uit. Het vertegenwoordigt de ongeordende reeks elementen waardoor we de dubbele items niet kunnen opslaan. We kunnen maximaal één nulwaarde opslaan in Set. Set wordt geïmplementeerd door HashSet, LinkedHashSet en TreeSet.

Set kan worden geïnstantieerd als:

 Set s1 = new HashSet(); Set s2 = new LinkedHashSet(); Set s3 = new TreeSet(); 

HashSet

HashSet-klasse implementeert Set Interface. Het vertegenwoordigt de verzameling die een hashtabel gebruikt voor opslag. Hashing wordt gebruikt om de elementen in de HashSet op te slaan. Er zitten unieke items in.

Beschouw het volgende voorbeeld.

 import java.util.*; public class TestJavaCollection7{ public static void main(String args[]){ //Creating HashSet and adding elements HashSet set=new HashSet(); set.add('Ravi'); set.add('Vijay'); set.add('Ravi'); set.add('Ajay'); //Traversing elements Iterator itr=set.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Uitgang:

 Vijay Ravi Ajay 

GekoppeldeHashSet

De klasse LinkedHashSet vertegenwoordigt de LinkedList-implementatie van Set Interface. Het breidt de HashSet-klasse uit en implementeert de Set-interface. Net als HashSet bevat het ook unieke elementen. Het handhaaft de invoegvolgorde en staat nulelementen toe.

Beschouw het volgende voorbeeld.

 import java.util.*; public class TestJavaCollection8{ public static void main(String args[]){ LinkedHashSet set=new LinkedHashSet(); set.add('Ravi'); set.add('Vijay'); set.add('Ravi'); set.add('Ajay'); Iterator itr=set.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Uitgang:

 Ravi Vijay Ajay 

SortedSet-interface

SortedSet is het alternatief voor de Set-interface die een totale volgorde van de elementen biedt. De elementen van de SortedSet zijn gerangschikt in oplopende (oplopende) volgorde. De SortedSet biedt de aanvullende methoden die de natuurlijke ordening van de elementen belemmeren.

De SortedSet kan worden geïnstantieerd als:

 SortedSet set = new TreeSet(); 

BoomSet

De Java TreeSet-klasse implementeert de Set-interface die een boom gebruikt voor opslag. Net als HashSet bevat TreeSet ook unieke elementen. De toegang- en ophaaltijd van TreeSet is echter vrij snel. De elementen in TreeSet worden in oplopende volgorde opgeslagen.

Beschouw het volgende voorbeeld:

 import java.util.*; public class TestJavaCollection9{ public static void main(String args[]){ //Creating and adding elements TreeSet set=new TreeSet(); set.add('Ravi'); set.add('Vijay'); set.add('Ravi'); set.add('Ajay'); //traversing elements Iterator itr=set.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Uitgang:

 Ajay Ravi Vijay 

1. ArrayList-klasse
2. LinkedList-klasse
3. Lijstinterface
4. HashSet-klasse
5. LinkedHashSet-klasse
6. TreeSet-klasse
7. PriorityQueue-klasse
8. Kaartinterface
9. HashMap-klasse
10. LinkedHashMap-klasse
11. TreeMap-klasse
12. Hashtable-klasse
13. Sorteren
14. Vergelijkbare interface
15. Vergelijkingsinterface
16. Eigenschappenklasse in Java