JCF-Tutorial (Java Collections Framework)

java collections framework tutorial

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

Wählen Sie Das Betriebssystem Aus Wählen Sie Ein Projektionsprogramm (Optional)

Beschreiben Sie Ihr Problem

In diesem Lernprogramm werden das Java Collections Framework (JCF) sowie die Sammlungshierarchie, verschiedene Schnittstellen und die Vorteile von JCF ausführlich erläutert:

Hoffe diese beredten Tutorials dazu Java-Serie für Anfänger sind wirklich hilfreich, um Ihre Java-Kenntnisse zu erweitern.

In unserem vorherigen Tutorial haben wir mehr über die Grundlegende E / A-Operationen in Java . In diesem Tutorial lernen wir das Java Collections Framework (JCF) im Detail kennen.

Java Collections Framework (JCF) enthält Schnittstellen, abstrakte Klassen und Klassen, die die Architektur zum Speichern und Bearbeiten einer Gruppe von Objekten bereitstellen können.

Java Collections Framework

Was du lernen wirst:

Video-Tutorials zum Java Collections Framework

Kenntnisse der Arraylist in Java:

Festlegen der Schnittstelle und der Warteschlangenschnittstelle in Java anhand von Echtzeitbeispielen:

HashMap, TreeMap und HashTable in Java:

Bisher haben wir Variablen gesehen, die verschiedene Datentypen speichern. Dies sind einzelne Einheiten und nicht sehr hilfreich, wenn Sie große Datenmengen speichern und verarbeiten müssen. Wie wir wissen, sind Daten der wichtigste Bestandteil der Computerverarbeitung.

Ihre Anwendung muss in der Lage sein, Daten zu extrahieren und zu sammeln, sie zu verarbeiten, um nützliche Informationen herauszufinden, und sie auch hin und her zu leiten, damit sie effizient zum Erreichen der Lösungen verwendet werden können.

In dieser Softwarewelt speichern wir die Daten, die auf eine bestimmte Weise strukturiert werden müssen, damit die Softwareprogramme die Ergebnisse speichern, lesen, verarbeiten und schließlich ausgeben können. Dies erfolgt über Datenstrukturen.

Fast alle Programmiersprachen unterstützen Datenstrukturen. Die Datenstruktur kann als strukturierte Darstellung von Daten definiert werden. Programmiersprachen bieten API-Funktionen (Application Programming Interface), um die Datenstrukturen zu manipulieren.

Need For Collection Framework

Vor Java 1.2 unterstützte die Programmiersprache Java Datenstrukturen wie Arrays, Vektoren oder Hash-Tabellen. Das Ausführen von Operationen an diesen Datenstrukturen war nicht einfach, da es keine gemeinsame Schnittstelle gab, die an diesen Datenstrukturen arbeitete.

Programmierer fanden es früher schwierig, Algorithmen zu schreiben, die für alle Datenstrukturen funktionieren würden, und waren ein großer Aufwand. Es bestand Bedarf an einer gemeinsamen Schnittstelle, die konsistent mit allen Datenstrukturen funktioniert und auch Operationen effizient ausführt.

Später entwickelte Java ein Sammlungsframework, das eine Gruppe von Klassen und Schnittstellen darstellt, die aus verschiedenen Operationen bestehen, die an Datenstrukturen ausgeführt werden können.

In diesem Tutorial zu Java-Sammlungen werden wir das Java-Sammlungs-Framework im Allgemeinen erläutern. Wir werden jede der Sammlungskomponenten in unseren kommenden Tutorials untersuchen.

Java Collections Framework

Bevor wir ein Java Collections Framework definieren, lernen wir die Bedeutung der Sammlung und eines Frameworks kennen.

Eine Sammlung kann als eine Gruppe von Objekten definiert werden. Eine Sammlung ist normalerweise eine einzelne Einheit, die aus mehr als einem Objekt besteht. Ein Framework ist eine Software, die über eine vorgefertigte funktionale Schnittstelle oder Architektur verfügt und außerdem eine Reihe von Klassen und Schnittstellen enthält, die mit der bereitgestellten Schnittstelle verwendet werden können.

Ein Sammlungsframework ist definiert als eine einheitliche, vorgefertigte Architektur, die aus den folgenden Elementen besteht.

# 1) Algorithmen

Dies sind Methoden oder Anweisungen, die Programmierern beim Suchen, Sortieren und Verarbeiten gesammelter Daten helfen können. Die Sammlung enthält Schnittstellen, Klassen und Algorithmen.

Die Anwendungen, die durch Vererbung des Erfassungsframeworks entwickelt werden, haben Zugriff auf diese Algorithmen und verwenden die bereits definierten Methoden und Verfahren.

# 2) Schnittstellen

Schnittstellen in Java stellen die Abstraktion der Implementierung bereit, d. H. Unter Verwendung von Schnittstellen sind dem Benutzer die Details der Implementierung nicht bekannt, er können jedoch nur die Methoden und Daten sehen, die zum Schreiben einer Anwendung erforderlich sind. Die Erfassungsschnittstelle verfügt über viele Schnittstellen, die vom Programmierer implementiert werden können, um eigene Klassen zu schreiben.

# 3) Klassen

Die Klassen von Collection Framework sind Datenstrukturen, die in einem Programm implementiert werden können. Diese Klassen implementieren die Schnittstelle 'Collection' und erben somit alle Methoden und Definitionen der Collection-Schnittstelle.

Ein Sammlungsframework wird zum Speichern und Bearbeiten der Sammlung verwendet, bei der es sich um die Gruppe von Objekten handelt.

Das Java Collection Framework besteht aus leistungsstarken Algorithmen, die Standardoperationen wie Suchen, Sortieren und Verarbeiten ausführen. Es bietet verschiedene Standardimplementierungen, einschließlich LinkedList, TreeSet und HashSet, für die Schnittstellen bereitgestellt werden.

Lassen Sie uns als Nächstes die Java-Sammlungshierarchie verstehen.

Java-Sammlungshierarchie

Alle in der folgenden Java Collection-Hierarchie gezeigten Klassen und Schnittstellen gehören zum Paket 'java.util. *'.

Java-Sammlungshierarchie

Wie im obigen Diagramm gezeigt, besteht die Java-Sammlungshierarchie aus verschiedenen Klassen und Schnittstellen. Wie Sie sehen können, erbt jede Klasse von einer Schnittstelle, und alle Klassen und Schnittstellen erben wiederum von einer einzigen 'Sammlungs' -Schnittstelle.

Lassen Sie uns einige gängige Methoden in der Sammlungsschnittstelle sowie eine kurze Einführung in die einzelnen Klassen und Schnittstellen erörtern, die in der obigen Hierarchie aufgeführt sind.

Sammlungsschnittstelle

Die Collection-Schnittstelle ist die Root-Schnittstelle. Alle Klassen im Sammlungsframework implementieren die Sammlungsschnittstelle. Dies bedeutet, dass für jede Sammlung die in der Sammlungsschnittstelle deklarierten Methoden vorhanden sind.

Einige der Methoden der Collection-Oberfläche sind unten angegeben.

Unterlassen Sie	Methodenprototyp	Beschreibung
7	Standard boolean removeIf (Prädikatfilter)	Entfernen Sie alle Elemente, die dem angegebenen Prädikat 'Filter' entsprechen, aus der Sammlung.
1	public int size ()	Gibt die Anzahl der Elemente in einer bestimmten Sammlung zurück.
zwei	public void clear ()	Löscht die Sammlung, indem alle Elemente aus der Sammlung entfernt werden.
3	public boolean add (E e)	Fügt ein Element e in die Sammlung ein.
4	public booleanaddAll (Sammlung c)	Fügen Sie alle Elemente in der von c angegebenen Sammlung in die Sammlung ein.
5	public boolean remove (Objektelement)	Löschen Sie das durch 'Element' angegebene Element aus der Sammlung.
6	public boolean removeAll (Collectionc)	Entfernen Sie die Sammlung c aus der Sammlung.
8	public booleanretainAll (Sammlung c)	Löschen Sie alle Elemente aus der Sammlung mit Ausnahme der Elemente in der angegebenen Sammlung. C.
9	öffentlicher Iterator iterator ()	Rückgabe des Iterators für die Sammlung.
10	öffentliches Objekt () toArray ()	Konvertieren Sie die Sammlung in ein Array.
elf	öffentliches T () toArray (T () a)	Konvertieren Sie die Sammlung in ein Array mit einem angegebenen Rückgabetyp.
12	public boolean isEmpty ()	Rückgabe, wenn die Sammlung leer ist oder nicht.
13	public boolean enthält (Objektelement)	Überprüfen Sie, ob eine Sammlung das angegebene Element enthält (Suchvorgang).
14	public booleancontainsAll (Collectionc)	Überprüfen Sie, ob die Sammlung die angegebene Sammlung c enthält.
fünfzehn	Standard Spliterator Spliterator ()	Gibt den Spliterator über eine angegebene Sammlung zurück.
16	öffentliche booleanequals (Objektelement)	Wird zum Abgleichen von zwei Sammlungen verwendet.
17	Standard Stream parallelStream ()	Gibt einen parallelen Stream zurück, der die Sammlung als Quelle verwendet.
18	Standard Streamstream ()	Gibt einen sequentiellen Stream zurück, der die Sammlung als Quelle verwendet.
19	public int hashCode ()	Gibt den numerischen Hashcode der Sammlung zurück.

Iterierbare Schnittstelle

Die Iterable-Schnittstelle ist auch die Basisschnittstelle des Sammlungsframeworks. Die Collection-Schnittstelle, die die übergeordnete Schnittstelle aller anderen Klassen ist, erweitert die Iterable-Schnittstelle. Daher implementieren alle Klassen eine Sammlungsschnittstelle sowie eine iterierbare Schnittstelle.

Die Iterable-Schnittstelle verfügt nur über eine Methode iterator (), die den iterator () zurückgibt, mit dem Sie über die Elemente vom Typ T iterieren können.

Iterator iterator ()

Iterator-Schnittstelle

Die Iterator-Schnittstelle bietet die Möglichkeit, die Elemente in Vorwärtsrichtung zu durchlaufen.

Die folgenden Methoden werden von dieser Schnittstelle unterstützt.

Unterlassen Sie	Methodenprototyp	Beschreibung
1	öffentliches Objekt next ()	Gibt zuerst das Element zurück und bewegt dann den Cursor, um auf das nächste Element zu zeigen.
zwei	public boolean hasNext ()	Überprüft, ob der Iterator mehr Elemente enthält.
3	public void remove ()	Entfernt das Element, das am Ende vom Iterator zurückgegeben wird.

Listenschnittstelle

Die Listenschnittstelle erbt die Sammlungsschnittstelle. Die Listenschnittstelle enthält die Datenstrukturen, die zum Speichern geordneter Daten oder zum Sammeln von Objekten verwendet werden. Diese Datenstrukturen sind vom Listentyp. Diese Datenstrukturen, die die Listenschnittstelle implementieren, können doppelte Werte aufweisen oder nicht.

Die Listenschnittstelle enthält die Methoden, mit denen auf Elemente aus den Listenobjekten zugegriffen, diese eingefügt oder aus diesen entfernt werden.

Verschiedene Klassen, die die List-Schnittstelle implementieren, sind wie folgt:

DVD-Kopiersoftware für Windows 10

Anordnungsliste
LinkedList
Vektor
Stapel

Wir werden jede dieser Klassen kurz besprechen. In unseren nachfolgenden Themen wird jede der Sammlungsrahmenklassen ausführlich besprochen.

# 1) ArrayList

ArrayList ist die einfachste Implementierung der List-Schnittstelle. ArrayList behält die Einfügereihenfolge bei und ist nicht synchronisiert.

Die allgemeine Definition der ArrayList-Datenstruktur (Sammlung) lautet wie folgt:

List list1= new ArrayList ();

Sobald die Liste definiert ist, können Sie mit der Methode 'Hinzufügen' Elemente hinzufügen. Beachten Sie, dass die ArrayList intern einen dynamischen Array-Mechanismus verwendet hat.

In den folgenden Beispielen wird eine ArrayList-Farbsammlung erstellt.

 import java.util.*; class Main { public static void main(String args()) { //Creating arraylist of String objects ArrayList color_list=new ArrayList(); //populate the arraylist with add method color_list.add('Red'); color_list.add('Green'); color_list.add('Blue'); color_list.add('Cyan'); color_list.add('Magenta'); color_list.add('Yellow'); //Traverse the list through Iterator Iterator itr=color_list.iterator(); System.out.println('The contents of the arraylist are:'); while(itr.hasNext()){ System.out.println(itr.next()); } } }

Ausgabe:

Anordnungsliste

Das obige Programm zeigt die Demonstration der ArrayList-Auflistung. Wir fügen der Sammlung Farbwerte hinzu und durchlaufen dann die Sammlung, um einzelne Werte in der Sammlung mithilfe eines Iterators anzuzeigen.

# 2) LinkedList

Die LinkedList-Auflistung verwendet intern einen doppelt verknüpften Listenmechanismus zum Speichern von Elementen. Es kann doppelte Elemente enthalten. LinkedList-Erfassungsvorgänge sind schneller, da keine Verschiebung von Elementen erforderlich ist.

Die allgemeine Definition zum Erstellen einer verknüpften Liste lautet wie folgt:

List list2 = new LinkedList ();

Das folgende Programm demonstriert die verknüpfte Listensammlung von Nummernnamen .

 import java.util.*; class Main { public static void main(String args()) { //linked list of String objects LinkedList linkedlist_num=new LinkedList(); linkedlist_num.add('one'); linkedlist_num.add('two'); linkedlist_num.add('three'); linkedlist_num.add('four'); linkedlist_num.add('five'); //iterate over the linked list to display contents Iterator itr=linkedlist_num.iterator(); System.out.println('The contents of the linked list are:'); while(itr.hasNext()) { System.out.println(itr.next()); } } }

Ausgabe:

LinkedList

Daher erstellen wir eine verknüpfte Liste und fügen ihr dann mithilfe der Methode 'Hinzufügen' Elemente hinzu. Dann durchlaufen wir mit einem Iterator die verknüpfte Liste und zeigen jedes Element an.

# 3) Vektor

Vector ähnelt ArrayList und verwendet ein dynamisches Array, um die Elemente wie ArrayList zu speichern. Vektor unterstützt jedoch neben der Sammlung viele unabhängige Methoden, die es zu einer besseren Wahl machen, eine bevorzugte Sammlung zu sein.

Die allgemeine Definition für die Vektorsammlung lautet:

List list3 = new Vector();

Beachten Sie, dass Vektor und ArrayList zwar denselben Mechanismus wie dynamische Arrays verwenden, die Vektorelemente jedoch synchronisiert sind.

Das unten angegebene Java-Programm demonstriert die Verwendung von Vektoren im Auflistungsframework .

 import java.util.*; public class Main { public static void main(String args()) { Vector subject_vector=new Vector(); subject_vector.add('English'); subject_vector.add('Hindi'); subject_vector.add('Maths'); subject_vector.add('Science'); Iterator itr=subject_vector.iterator(); System.out.println('Vector contents:'); while(itr.hasNext()) { System.out.println(itr.next()); } } }

Ausgabe:

Vektor

In diesem Programm haben wir eine Vektorsammlung definiert, die aus Subjekten besteht. Wir fügen verschiedene Themen hinzu und verwenden dann einen Iterator, um die Elemente auszugeben.

# 4) Stapeln

Die Stapeldatenstruktur implementiert die LIFO-Methode (Last-In-First-Out) zum Einfügen von Elementen. Der Stapel ist eine Unterklasse des Klassenvektors (siehe obiges Diagramm der Sammlungshierarchie). Neben den eigenen Methoden unterstützt die Stapelsammlung auch die Methoden der Vektorsammlung.

Die allgemeine Definition der Stapelsammlung lautet:

List list4 = new Stack();

Das folgende Programm implementiert die Stapelsammlung .

 import java.util.*; public class Main { public static void main(String args()) { Stack  even_stack = new Stack (); even_stack.push(2); even_stack.push(4); even_stack.push(6); even_stack.push(8); even_stack.push(10); System.out.println('The element removed from stack: ' + even_stack.pop()); Iterator  itr=even_stack.iterator(); System.out.println('The contents of the stack are:'); while(itr.hasNext()) { System.out.print(itr.next() + ' '); } } }

Ausgabe:

Stapelsammlung

Wie Sie in der obigen Implementierung sehen können, werden die neuen Elemente mithilfe von dem Stapel hinzugefügt 'drücken' Operation. Der Stapel hat einen einzelnen Einstiegspunkt namens 'Top of the Stack' und die Elemente werden oben auf den Stapel geschoben. Somit befindet sich das zuletzt hinzugefügte Element oben im Stapel.

Wie beim Hinzufügen werden auch Elemente von einem Ende entfernt, d. H. Oben auf dem Stapel. Um Elemente zu entfernen, wird eine Operation 'Pop' verwendet. Wenn Sie also pop () aufrufen, wird das Element oben im Stapel entfernt.

In der obigen Ausgabe fügen wir das Element 2, 4, 6,8,10 ein und rufen dann pop () auf, sodass 10 entfernt wird.

Warteschlangenschnittstelle

Die von der Warteschlangenschnittstelle abgeleiteten Sammlungen folgen der FIFO-Reihenfolge (First-In-First-Out). Die Elemente werden an einem Ende eingefügt und am anderen Ende entfernt. Daher ist das zuerst eingegebene Element zufällig das Element, das zuerst entfernt wird.

Im Folgenden sind die Sammlungen aufgeführt, die die Abfrageschnittstelle unterstützen.

Prioritätswarteschlange
und Schnittstelle
ArrayDeque

Lassen Sie uns diese kurz besprechen.

# 1) PriorityQueue

In der PriorityQueue-Auflistung werden die gespeicherten Elemente basierend auf ihren Prioritäten verarbeitet. Sie können keine Nullwerte in der Prioritätswarteschlange speichern.

Die allgemeine Definition der Prioritätswarteschlange lautet wie folgt:

Queue q1 = new PriorityQueue();

Das folgende Programm implementiert die Prioritätswarteschlange.

 import java.util.*; public class Main { public static void main(String args()) { PriorityQueue color_queue=new PriorityQueue(); color_queue.add('red'); color_queue.add('green'); color_queue.add('blue'); color_queue.add('cyan'); color_queue.add('magenta'); color_queue.add('yellow'); System.out.println('Priority Queue elements:'); System.out.println('head:'+color_queue.peek()); System.out.println('Other elements in Priority Queue:'); Iterator itr=color_queue.iterator(); while(itr.hasNext()) { System.out.print(itr.next() + ' '); } System.out.println('
'); color_queue.remove(); System.out.println('After removing element, new head:'+color_queue.element()); System.out.println('
'); color_queue.poll(); System.out.println('After removing another element, Priority Queue :'); Iterator itr2=color_queue.iterator(); while(itr2.hasNext()) { System.out.print(itr2.next() + ' '); } } }

Ausgabe:

Prioritätswarteschlange

Wieder verwenden wir Farben als Elemente der Prioritätswarteschlange. Im obigen Programm haben wir die Methoden add und remove verwendet, um Elemente zur Warteschlange hinzuzufügen bzw. ein Element zu entfernen. Wir verwenden die peek () -Methode, die ein Element zurückgibt, auf das es in der Prioritätswarteschlange zeigt.

Schließlich werden mithilfe eines Iterators die Elemente der Prioritätswarteschlange angezeigt.

# 2) Touch-Oberfläche

Deque oder eine 'Double-Ended Queue' ist eine Datenstruktur, mit der Sie die Elemente an beiden Enden hinzufügen und entfernen können. Die Deque-Schnittstelle im Java-Auflistungsframework, die die Warteschlangenschnittstelle erweitert.

Es bietet die Funktionalität von deque und verfügt über eine Klasse, die von einem ArrayDeque geerbt wird.

# 3) ArrayDeque

ArrayDeque implementiert die Deque-Schnittstelle.

Die allgemeine Definition von ArrayDeque lautet wie folgt:

Deque d = new ArrayDeque();

Mit ArrayDeque können Sie die Funktionalität von Deque nutzen. Im Gegensatz zu anderen Sammlungen wie ArrayList oder Stack unterliegt ArrayDeque keinen Kapazitätsbeschränkungen.

Das folgende Beispiel zeigt die Implementierung von ArrayDeque.

 import java.util.*; public class Main { public static void main(String() args) { //Creating Deque and adding elements Deque  deque = new ArrayDeque (); deque.add(10); deque.add(20); deque.add(30); System.out.println('Deque Elements:'); //Traversing elements for (Integer num : deque) { System.out.println(num); } } }

Ausgabe:

ArrayDeque

Im obigen Programm definieren wir eine ArrayDeque-Auflistung vom Typ Integer und fügen ihr mit der Methode add Integer-Elemente hinzu. Die Sammlung wird dann mit dem for-Konstrukt durchlaufen.

Schnittstelle einstellen

Die Set-Schnittstelle ist Teil des Pakets java.util und erstreckt sich über die Auflistungsschnittstelle. Set ist eine Struktur, die es der Sammlung nicht erlaubt, doppelte Werte und auch mehr als einen Nullwert zu haben.

Die folgenden Klassen implementieren die Set-Schnittstelle.

HashSet
LinkedHashSet
TreeSet

# 1) HashSet

In der HashSet-Sammlung, die die Set-Schnittstelle implementiert, sind unterschiedliche Werte gespeichert. Diese Sammlung verwendet die Hashing-Technik zum Speichern der Elemente und die Hash-Tabelle zum Speichern von Elementen.

T. Die allgemeine Definition der HashSet-Sammlung ist unten dargestellt.

Set s1 = new HashSet();

Wir haben die HashSet-Implementierung im folgenden Programm angegeben.

 import java.util.*; public class Main { public static void main(String args()) { //Create HashSet set_subjects HashSet set_subjects=new HashSet(); System.out.println('Elements in the given hashsetset_subjects are:'); set_subjects.add('Maths'); set_subjects.add('Computers'); set_subjects.add('English'); set_subjects.add('French'); //Traverse the hashset Iterator itr=set_subjects.iterator(); while(itr.hasNext()) { System.out.println(itr.next()); } } }

Ausgabe:

Array in ein anderes Java-Array kopieren

HashSet

Im obigen Programm erstellen wir eine HashSet-Sammlung von Themen und durchlaufen sie dann mit einem Iterator, um die Elemente in der Sammlung anzuzeigen.

# 2) LinkedHashSet

LinkedHashSet implementiert eine festgelegte Schnittstelle und erweitert HashSet (siehe Sammlungshierarchie). LinkedHashSet ist die verknüpfte Listendarstellung des Schnittstellensets. LinkedHashSet enthält eindeutige Elemente, lässt jedoch Nullwerte zu.

Die allgemeine Definition von LinkedHashSet ist unten angegeben.

Set s2 = new LinkedHashSet();

Die Implementierung für LinkedHashSet ist unten angegeben.

 import java.util.*; public class Main { public static void main(String args()) { LinkedHashSet set_subjects=new LinkedHashSet(); System.out.println('Elements in the LinkedHashSet set_subjects:'); set_subjects.add('Maths'); set_subjects.add('Computers'); set_subjects.add('English'); set_subjects.add('Sanskrit'); Iterator itr=set_subjects.iterator(); while(itr.hasNext()) { System.out.println(itr.next()); } } }

Ausgabe:

LinkedHashSet

Wir verwenden wieder Buchtitel, um Linkedhashset zu erstellen. Wie Sie der Ausgabe entnehmen können, wird die Reihenfolge der Addition von linkedHashSet beibehalten.

SortedSet-Schnittstelle

Die SortedSet-Schnittstelle ermöglicht die vollständige Reihenfolge der Elemente. Es enthält Methoden, die eine natürliche Reihenfolge der Elemente ermöglichen. Elemente in der Sammlung, die die SortedSet-Schnittstelle implementieren, sind in aufsteigender Reihenfolge angeordnet.

Die TreeSet-Klasse ist eines der Beispiele, die die SortedSet-Schnittstelle implementieren.

Baumset

Die allgemeine Definition von Treeset lautet wie folgt:

Set s3 = new TreeSet();

TreeSet implementiert die SortedSet-Schnittstelle und enthält eindeutige Elemente. Das Speichern und Abrufen ist ziemlich schnell und dann werden die Elemente in aufsteigender Reihenfolge angeordnet.

 import java.util.*; public class Main{ public static void main(String args()) { //create a treeset of integers TreeSet  set_oddnums=new TreeSet (); set_oddnums.add(1); set_oddnums.add(3); set_oddnums.add(5); set_oddnums.add(7); set_oddnums.add(9); System.out.println('Elements in TreeSet are:'); //traverse the treeset using iterator Iterator  itr=set_oddnums.iterator(); while(itr.hasNext()) { System.out.print(itr.next() + ' '); } } }

Ausgabe:

Baumset

Im obigen Programm haben wir ungerade Zahlen mit add-Methoden erstellt und zur Sammlung hinzugefügt. Anschließend geben wir mit einem Iterator die Elemente in der Sammlung aus.

Vorteile des Java Collections Framework

Reduzierte Programmierung: Das Collections-Framework enthält alle Schnittstellen und Klassen, die die Methoden enthalten, mit denen Programmierer ein effizientes Programm schreiben können. Auf diese Weise muss sich der Programmierer nicht auf zu viel Programmierung konzentrieren.
Konsistente Methoden und API: Alle Klassen haben gemeinsame Methoden, die auf Daten wirken. Diese APIs sind in allen Klassen konsistent und der Programmierer muss sich nicht darum kümmern, zu viele verschiedene Methoden für jede Klasse zu haben.
Erhöhen Sie Geschwindigkeit und Genauigkeit: Sie können hocheffiziente Programme mithilfe eines Erfassungsframeworks sowie schneller und genauer Programme schreiben, da das Erfassungsframework die volle Funktionalität zum Implementieren der Datenstrukturen und Sammlungen bietet.
Erleichtert die Wiederverwendung von Software: Datenstrukturen und Algorithmen des Java Collection Framework sind wiederverwendbar.
Interoperabilität zwischen nicht verwandten APIs: Sammlungs-APIs ermöglichen die Interoperabilität auch zwischen nicht verwandten APIs.
Weniger Anstrengungen zum Entwerfen neuer APIs: Programmierer können die Standard-Sammlungs-APIs verwenden und darauf basierend neue APIs entwerfen. Sie müssen sich nicht abmühen, komplett neue APIs zu schreiben.

Häufig gestellte Fragen

# 1) Was ist die Verwendung eines Sammlungsframeworks in Java?

Antworten: Das Collection Framework bietet vorgefertigte Algorithmen, Schnittstellen und Klassen, mit denen Programmierer hocheffiziente Programme schreiben können, mit denen Daten gespeichert und verarbeitet werden können.

# 2) Warum ist Sammlung ein Rahmen?

Antworten: Ein Framework ist eine wiederverwendbare Sammlung von Klassen, Schnittstellen und Algorithmen. Das Erfassungsframework ist auch eine wiederverwendbare Sammlung von Datenstrukturklassen und Algorithmen, die mit diesen Klassen arbeiten.

# 3) Was ist die Java Collections API in Java?

Antworten: Die Java-Sammlungs-API bietet Schnittstellen und Klassen, die erweitert und implementiert werden können, um Datenstrukturen zu verwenden, die nichts anderes als Sammlungen sind.

# 4) Was ist der Unterschied zwischen Sammlung und Sammlungen in Java?

Antworten: Die Sammlung ist eine Basisschnittstelle im Sammlungsframework, während 'Sammlungen' eine Klasse ist. Beide sind Teil des Pakets java.util.

**** Weitere Details und Beispiele des Java Collections Framework: ****

Java Collection-Schnittstelle

Vergleich zwischen Liste, Satz und Warteschlange:

Liste	einstellen	Warteschlange
Einfügereihenfolge bleibt erhalten	Die Einfügereihenfolge wird im Hash-Set nicht beibehalten	Einfügereihenfolge bleibt erhalten.
Kann doppelte Elemente enthalten	Kann keine doppelten Elemente enthalten	Kann doppelte Elemente enthalten.
Das Einfügen und Entfernen des Arrays kann für jeden Index erfolgen.	Entfernen Sie das angegebene Element.	Nur das zuletzt eingefügte Element kann herausspringen. Das Einfügen von Elementen erfolgt am Ende.

Array-Listenklasse

In Array ist die Speicherzuordnung festgelegt. In ArrayList kann der Speicher jedoch dynamisch zugewiesen werden. Diese ArrayList-Klasse behält die Einfügereihenfolge bei und Sie können doppelte Elemente einfügen.

Demo-Programm für Array-Liste:

 public class ArrayListDemo { public static void main(String() args) { ArrayList li = new ArrayList (); li.add(1); li.add(2); li.add(3); li.remove(0); for (Integer temp : li) { System.out.println(temp); } System.out.println('=========='); ArrayList l = new ArrayList(); l.add('text1'); l.add('text2'); l.add('text3'); for (String temp : l) { System.out.println(temp); } System.out.println('=========='); ArrayList al=new ArrayList(); al.add(1); al.add(2); al.forEach((a)->;System.out.println(a)); } }

Array-Listenklasse

LinkedList-Klasse

Die Datenstruktur der verknüpften Liste enthält Knoten, und dieser Knoten besteht aus zwei Teilen:

Daten
Verweis auf das nächste Element

Der erste Knoten ist kein separater Knoten. Es enthält nur die Referenz und wird als Kopf bezeichnet. Der letzte Knoten ist null.

Verknüpfte Listenklasse

Demo-Programm:

 public class LinkedListDemo { public static void main(String() args) { LinkedList list =new LinkedList(); list.add(22); list.add(44); list.add(46); list.add(46); list.add(46); for(Integer temp:list) { System.out.println(temp); } Iterator it =list.iterator(); while(it.hasNext()) { System.out.println(it.next()); } System.out.println('=========='); for (int i=0;i 
  Warteschlange 
 Eine Warteschlange ist die FIFO-Datenstruktur (First In First Out). Wenn Sie die Methode remove aufrufen, wird immer das erste eingefügte Element aus der Warteschlange entfernt. Die Warteschlange wird also in Echtzeitanwendungen verwendet, bei denen die Daten in der eingefügten Reihenfolge abgerufen werden müssen.
  Beispielprogramm: 
 public class QueueDemo { public static void main(String() args) { PriorityQueue pq=new PriorityQueue(); pq.add(1); pq.add(2); pq.add(3); pq.add(4); pq.add(5); pq.add(6); pq.add(7); for(int temp : pq) { System.out.println(temp); } pq.remove(); System.out.println('queue after removing a element'); System.out.println(pq); } }  
  einstellen 
 Eine Set-Sammlung erlaubt keine doppelten Elemente. Sie können eine festgelegte Datenstruktur verwenden, wenn Sie die Datenerfassung ohne Duplizierung verarbeiten möchten und die Einfügereihenfolge nicht beibehalten werden muss.
  Demo-Programm: 
 public class demohashset { public static void main (String() args){ HashSet hs=new HashSet(); hs.add(23); hs.add(24); hs.add(25); hs.add(26); hs.add(27); hs.add(28); hs.add(293); hs.add(203); hs.add(263); hs.add(243); hs.add(243); (int temp:hs) { System.out.println(temp); } hs.remove(24); hs.remove(23); System.out.println('==============='); System.out.println('after removing a element ::::'); System.out.println('==============='); hs.forEach((temp)->System.out.println(temp)); ; } }  
  MAP-Schnittstelle 
  Wenn Sie die Prozesssammlung von Elementen mit dem Schlüssel- und Wertepaar verarbeiten möchten, können Sie die Kartendatenstruktur verwenden, da die Karte ein Objekt ist, das Schlüssel Werten zuordnen kann.
 Eine Karte darf keine doppelten Schlüssel enthalten.
 Die wichtigen Implementierungen von Map sind HashMap, Treemap, LinkedHashMap, HashTable.
 
  Unterschied zwischen HashMap, Treemap, LinkedHashMap und HashTable: 
   HashMap Baumkarte LinkedHashmap Hash-tabelle  
 
   
  Nullschlüssel und Werte sind zulässig Es sind nur Nullwerte zulässig. Nullschlüssel und Werte erlaubt. Es werden keine Nullschlüssel und -werte zugelassen.  
  Nicht synchronisiert Nicht synchronisiert Nicht synchronisiert synchronisiert  
  Es gibt keine Garantie für die Aufrechterhaltung der Reihenfolge in der Iteration Die Sortierung erfolgt nach natürlicher Reihenfolge. Die Einfügereihenfolge wird beibehalten Einfügereihenfolge nicht gepflegt.  
 
 
  Demo-Programm: 
 public class HashMapDemo { public static void main(String() args) { HashMap m=new HashMap(); m.put(1, 'one'); m.put(2, 'two'); m.put(3, 'three'); m.put(4, 'four'); m.put(null, 'one'); m.put(null, null); System.out.println(m); TreeMap tm =new TreeMap(); tm.put('R', 'red'); tm.put('B', null); tm.put('G', 'green'); System.out.println(tm); Hashtable ht =new Hashtable(); ht.put(1, 'one'); ht.put(2, 'two'); ht.put(3, 'three'); ht.put(4, 'four'); System.out.println(ht); } }  
  Wichtige zu beachtende Punkte: 
  Listen-, Warteschlangen- und Set-Schnittstellen erweitern die Erfassungsschnittstelle, und diese Erfassungsschnittstelle verfügt über gängige Methoden wie Hinzufügen, Entfernen usw.
 Die Einfügereihenfolge wird in der Liste beibehalten und ein Satz darf keine doppelten Elemente enthalten. Die Warteschlange ist die First-in-First-out-Datenstruktur.
 Die Karte enthält Schlüssel- und Wertepaare. HashMap, Treemap, Hashtable und Linked HashMap sind die wichtige Implementierung der Kartenschnittstelle.
 
 Fazit
 Dieses Tutorial gab uns eine Einführung in das Java Collections Framework. Wir haben kurz alle Klassen und Schnittstellen angesprochen, die Teil des Java-Sammlungsframeworks sind.
 In unseren nachfolgenden Tutorials in dieser Reihe werden wir detailliert auf jede dieser Klassen und Schnittstellen eingehen.
   Weitere Informationen zu Reflections in JAVA finden Sie in unserem kommenden Tutorial !!!  
   PREV Tutorial | NÄCHSTES Tutorial  
  Literatur-Empfehlungen
    Java Reflection Tutorial mit Beispielen  
  Ausführliche Eclipse-Tutorials für Anfänger  
  Java SWING Tutorial: Container-, Komponenten- und Ereignisbehandlung  
  JAVA-Tutorial für Anfänger: Über 100 praktische Java-Video-Tutorials  
  Zugriffsmodifikatoren in Java - Tutorial mit Beispielen  
  Java String mit String Buffer und String Builder Tutorial  
  Einführung in die Java-Programmiersprache - Video-Tutorial  
  Cucumber Selenium Tutorial: Integration von Cucumber Java Selenium WebDriver