logo

Sammlungen in Java

Jede Gruppe einzelner Objekte, die als eine Einheit dargestellt werden, wird als Java-Objektsammlung bezeichnet. In Java gibt es ein separates Framework namens Sammlungsrahmen wurde in JDK 1.2 definiert, das alle darin enthaltenen Java-Sammlungsklassen und -Schnittstellen enthält.

In Java ist die Collection-Schnittstelle ( java.util.Collection ) und Kartenschnittstelle ( java.util.Map ) sind die beiden Hauptstammschnittstellen von Java-Sammlungsklassen.

Was sollten Sie in Java-Sammlungen lernen?

  • SortedSet-Schnittstelle
    • NavigableSet-Schnittstelle
    • TreeSet
    • ConcurrentSkipListSet-Klasse
  • Kartenschnittstelle
    • SortedMap-Schnittstelle
    • NavigableMap-Schnittstelle
    • ConcurrentMap-Schnittstelle
    • TreeMap-Klasse
    • AbstractMap-Klasse
    • ConcurrentHashMap-Klasse
    • EnumMap-Klasse
    • HashMap-Klasse
    • IdentityHashMap-Klasse
    • LinkedHashMap-Klasse
    • HashTable-Klasse
    • Eigenschaftenklasse
  • Andere wichtige Konzepte
    • So konvertieren Sie HashMap in ArrayList
    • Wählen Sie zufällig Elemente aus einer Liste aus
    • So fügen Sie alle Elemente aus einer Sammlung zu einer ArrayList hinzu
    • Konvertierung von Java Maps in eine Liste
    • Konvertierung von Array zu ArrayList
    • ArrayList-zu-Array-Konvertierung
    • Unterschiede zwischen Array und ArrayList



Was ist ein Framework in Java?

Ein Framework ist eine Reihe von Klassen und Schnittstellen, die eine vorgefertigte Architektur bereitstellen. Um ein neues Feature oder eine Klasse zu implementieren, ist es nicht erforderlich, ein Framework zu definieren. Ein optimaler objektorientierter Entwurf umfasst jedoch immer ein Framework mit einer Sammlung von Klassen, sodass alle Klassen die gleiche Art von Aufgabe ausführen.

Notwendigkeit eines separaten Sammlungsframeworks in Java

Vor der Einführung des Collection Framework (oder vor JDK 1.2) gab es die Standardmethoden zum Gruppieren von Java-Objekten (oder Sammlungen). Arrays oder Vektoren , oder Hashtabellen . Alle diese Sammlungen hatten keine gemeinsame Schnittstelle. Obwohl das Hauptziel aller Sammlungen das gleiche ist, wurde die Umsetzung aller dieser Sammlungen unabhängig voneinander definiert und hatte keinen Zusammenhang zwischen ihnen. Und außerdem ist es für die Benutzer sehr schwierig, sich an alle Unterschiede zu erinnern Methoden , Syntax und Konstrukteure in jeder Sammlungsklasse vorhanden.
Lassen Sie uns dies anhand eines Beispiels für das Hinzufügen eines Elements in einer Hashtabelle und eines Vektors verstehen.

js mehrzeilige Zeichenfolge

Beispiel:

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()> >}> }>

>

>

Ausgabe

1 1 geeks>

Wie wir beobachten können, implementiert keine dieser Sammlungen (Array, Vector oder Hashtable) eine Standardschnittstelle für den Zugriff auf Mitglieder. Daher war es für Programmierer sehr schwierig, Algorithmen zu schreiben, die für alle Arten von Sammlungen funktionieren. Ein weiterer Nachteil besteht darin, dass die meisten „Vector“-Methoden final sind, was bedeutet, dass wir die „Vector“-Klasse nicht erweitern können, um eine ähnliche Art von Sammlung zu implementieren. Aus diesem Grund beschlossen Java-Entwickler, eine gemeinsame Schnittstelle zu entwickeln, um die oben genannten Probleme zu lösen, und führten das Collection Framework im JDK 1.2-Beitrag ein, in dem sowohl ältere Vektoren als auch Hashtables geändert wurden, um mit dem Collection Framework übereinzustimmen.

Vorteile des Java Collection Framework

Da das Fehlen eines Sammlungsrahmens zu den oben genannten Nachteilen führte, sind die folgenden Vorteile des Sammlungsrahmens aufgeführt.

  1. Konsistente API: Die API verfügt über einen grundlegenden Satz von Schnittstellen wie Sammlung , Satz , Aufführen , oder Karte , alle Klassen (ArrayList, LinkedList, Vector usw.), die diese Schnittstellen implementieren, haben manche gemeinsame Reihe von Methoden.
  2. Reduziert den Programmieraufwand: Ein Programmierer muss sich nicht um das Design der Sammlung kümmern, sondern kann sich auf deren optimale Verwendung in seinem Programm konzentrieren. Daher wurde das Grundkonzept der objektorientierten Programmierung (d. h. Abstraktion) erfolgreich implementiert.
  3. Erhöht die Programmgeschwindigkeit und -qualität: Erhöht die Leistung durch die Bereitstellung leistungsstarker Implementierungen nützlicher Datenstrukturen und Algorithmen, da der Programmierer in diesem Fall nicht über die beste Implementierung einer bestimmten Datenstruktur nachdenken muss. Er kann einfach die beste Implementierung nutzen, um die Leistung seines Algorithmus/Programms drastisch zu steigern.

Hierarchie des Collection Framework in Java

Das Dienstprogrammpaket (java.util) enthält alle Klassen und Schnittstellen, die für das Sammlungsframework erforderlich sind. Das Sammlungs-Framework enthält eine Schnittstelle namens iterierbare Schnittstelle, die es dem Iterator ermöglicht, alle Sammlungen zu durchlaufen. Diese Schnittstelle wird um die Hauptsammlungsschnittstelle erweitert, die als Root für das Sammlungsframework fungiert. Alle Sammlungen erweitern diese Sammlungsschnittstelle und erweitern damit die Eigenschaften des Iterators und die Methoden dieser Schnittstelle. Die folgende Abbildung veranschaulicht die Hierarchie des Sammlungsframeworks.

Bevor wir die verschiedenen Komponenten im obigen Framework verstehen, wollen wir zunächst eine Klasse und eine Schnittstelle verstehen.

  • Klasse : Eine Klasse ist ein benutzerdefinierter Entwurf oder Prototyp, aus dem Objekte erstellt werden. Es stellt den Satz von Eigenschaften oder Methoden dar, die allen Objekten eines Typs gemeinsam sind.
  • Schnittstelle : Wie eine Klasse kann eine Schnittstelle Methoden und Variablen haben, aber die in einer Schnittstelle deklarierten Methoden sind standardmäßig abstrakt (nur Methodensignatur, niemand). Schnittstellen geben an, was eine Klasse tun muss und nicht wie. Es ist die Blaupause der Klasse.

Methoden der Collection-Schnittstelle

Diese Schnittstelle enthält verschiedene Methoden, die von allen Sammlungen, die diese Schnittstelle implementieren, direkt verwendet werden können. Sie sind:

Methode

Beschreibung

add(Objekt) Mit dieser Methode wird ein Objekt zur Sammlung hinzugefügt.
addAll(Sammlung c) Diese Methode fügt alle Elemente in der angegebenen Sammlung zu dieser Sammlung hinzu.
klar() Diese Methode entfernt alle Elemente aus dieser Sammlung.
enthält(Objekt o) Diese Methode gibt true zurück, wenn die Sammlung das angegebene Element enthält.
enthältAlle(Sammlung c) Diese Methode gibt true zurück, wenn die Sammlung alle Elemente in der angegebenen Sammlung enthält.
equal(Objekt o) Diese Methode vergleicht das angegebene Objekt mit dieser Sammlung auf Gleichheit.
Hash-Code() Diese Methode wird verwendet, um den Hash-Codewert für diese Sammlung zurückzugeben.
ist leer() Diese Methode gibt true zurück, wenn diese Sammlung keine Elemente enthält.
Iterator() Diese Methode gibt einen Iterator über die Elemente in dieser Sammlung zurück.
max()
Diese Methode wird verwendet, um den in der Sammlung vorhandenen Maximalwert zurückzugeben.
parallelStream() Diese Methode gibt einen parallelen Stream mit dieser Sammlung als Quelle zurück.
entfernen(Objekt o) Mit dieser Methode wird das angegebene Objekt aus der Sammlung entfernt. Wenn doppelte Werte vorhanden sind, entfernt diese Methode das erste Vorkommen des Objekts.
RemoveAll(Sammlung c) Mit dieser Methode werden alle in der angegebenen Sammlung erwähnten Objekte aus der Sammlung entfernt.
removeIf(Prädikatfilter) Diese Methode wird verwendet, um alle Elemente dieser Sammlung zu entfernen, die die gegebenen Anforderungen erfüllen Prädikat .
keepAll(Collection c) Diese Methode wird verwendet, um nur die Elemente in dieser Sammlung beizubehalten, die in der angegebenen Sammlung enthalten sind.
Größe() Diese Methode wird verwendet, um die Anzahl der Elemente in der Sammlung zurückzugeben.
Splitterator() Mit dieser Methode wird ein erstellt Spliterator über die Elemente in dieser Sammlung.
Strom() Diese Methode wird verwendet, um einen sequentiellen Stream mit dieser Sammlung als Quelle zurückzugeben.
toArray() Mit dieser Methode wird ein Array zurückgegeben, das alle Elemente dieser Sammlung enthält.

Schnittstellen, die die Java Collections-Schnittstelle erweitern

Das Sammlungsframework enthält mehrere Schnittstellen, wobei jede Schnittstelle zum Speichern eines bestimmten Datentyps verwendet wird. Im Folgenden sind die im Framework vorhandenen Schnittstellen aufgeführt.

1. Iterierbare Schnittstelle

Dies ist die Root-Schnittstelle für das gesamte Sammlungsframework. Die Collection-Schnittstelle erweitert die iterierbare Schnittstelle. Daher implementieren grundsätzlich alle Schnittstellen und Klassen diese Schnittstelle. Die Hauptfunktionalität dieser Schnittstelle besteht darin, einen Iterator für die Sammlungen bereitzustellen. Daher enthält diese Schnittstelle nur eine abstrakte Methode, nämlich den Iterator. Es gibt die zurück

Iterator iterator();>

2. Sammlungsschnittstelle

Diese Schnittstelle erweitert die iterierbare Schnittstelle und wird von allen Klassen im Sammlungsframework implementiert. Diese Schnittstelle enthält alle grundlegenden Methoden, über die jede Sammlung verfügt, z. B. das Hinzufügen von Daten zur Sammlung, das Entfernen von Daten, das Löschen von Daten usw. Alle diese Methoden sind in dieser Schnittstelle implementiert, da diese Methoden von allen Klassen unabhängig von ihrem Stil implementiert werden der Umsetzung. Und wenn diese Methoden in dieser Schnittstelle vorhanden sind, wird außerdem sichergestellt, dass die Namen der Methoden für alle Sammlungen universell sind. Kurz gesagt können wir daher sagen, dass diese Schnittstelle eine Grundlage bildet, auf der die Sammlungsklassen implementiert werden.

3. Listenschnittstelle

Dies ist eine untergeordnete Schnittstelle der Sammlungsschnittstelle. Diese Schnittstelle ist den Daten des Listentyps gewidmet, in denen wir alle geordneten Sammlungen der Objekte speichern können. Dadurch können auch doppelte Daten darin vorhanden sein. Diese Listenschnittstelle wird von verschiedenen Klassen wie ArrayList, Vector, Stack usw. implementiert. Da alle Unterklassen die Liste implementieren, können wir mit jeder dieser Klassen ein Listenobjekt instanziieren.

Zum Beispiel:

List al = new ArrayList ();  List ll = new LinkedList ();  List v = new Vector ();  Where T is the type of the object>

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

ich). Anordnungsliste

ArrayList stellt uns dynamische Arrays in Java zur Verfügung. Es ist zwar möglicherweise langsamer als Standard-Arrays, kann aber in Programmen hilfreich sein, bei denen viele Manipulationen im Array erforderlich sind. Die Größe einer ArrayList wird automatisch erhöht, wenn die Sammlung größer wird, oder kleiner, wenn die Objekte aus der Sammlung entfernt werden. Mit Java ArrayList können wir zufällig auf die Liste zugreifen. ArrayList kann nicht verwendet werden Wrapper-Klasse für solche Fälle.

Lassen Sie uns die ArrayList anhand des folgenden Beispiels verstehen:

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) + ' '); } }>

>

>

Ausgabe

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>

ii). LinkedList

Die LinkedList-Klasse ist eine Implementierung von Lassen Sie uns die LinkedList anhand des folgenden Beispiels verstehen:

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) + ' '); } }>

>

>

Ausgabe

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>

iii). Vektor

Ein Vektor stellt uns dynamische Arrays in Java zur Verfügung. Es ist zwar möglicherweise langsamer als Standard-Arrays, kann aber in Programmen hilfreich sein, bei denen viele Manipulationen im Array erforderlich sind. Dies ist hinsichtlich der Implementierung identisch mit ArrayList. Der Hauptunterschied zwischen einem Vektor und einer ArrayList besteht jedoch darin, dass ein Vector synchronisiert und eine ArrayList nicht synchronisiert ist.

Lassen Sie uns den Vektor anhand eines Beispiels verstehen:

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) + ' '); } }>

>

>

Ausgabe

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>

iv). Stapel

Stack-Klasse modelliert und implementiert diezuletzt rein, zuerst raus. Zusätzlich zu den grundlegenden Push- und Pop-Operationen bietet die Klasse drei weitere Funktionen: Empty, Search und Peek. Die Klasse kann auch als Unterklasse von Vector bezeichnet werden.

Lassen Sie uns den Stapel anhand eines Beispiels verstehen:

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() +>' '>);> >}> >}> }>

>

>

Ausgabe

Geeks For Geeks Geeks Geeks For Geeks>

Notiz: Stack ist eine Unterklasse von Vector und eine Legacy-Klasse. Es ist Thread-sicher, was in einer Umgebung, in der Thread-Sicherheit nicht erforderlich ist, zu einem Mehraufwand führen kann. Eine Alternative zu Stack ist die Verwendung von ArrayDequeue Dies ist nicht threadsicher und verfügt über eine schnellere Array-Implementierung.

4. Warteschlangenschnittstelle

Wie der Name schon sagt, behält eine Warteschlangenschnittstelle die FIFO-Reihenfolge (First In First Out) bei, ähnlich wie bei einer realen Warteschlange. Diese Schnittstelle dient der Speicherung aller Elemente, bei denen die Reihenfolge der Elemente von Bedeutung ist. Wenn wir beispielsweise versuchen, ein Ticket zu buchen, werden die Tickets nach dem Prinzip „Wer zuerst kommt, mahlt zuerst“ verkauft. Daher erhält die Person, deren Anfrage zuerst in der Warteschlange ankommt, das Ticket. Es gibt verschiedene Klassen wie Prioritätswarteschlange , ArrayDeque usw. Da alle diese Unterklassen die Warteschlange implementieren, können wir mit jeder dieser Klassen ein Warteschlangenobjekt instanziieren.

Zum Beispiel:

Queue pq = new PriorityQueue ();  Queue ad = new ArrayDeque ();  Where T is the type of the object.>

Die am häufigsten verwendete Implementierung der Warteschlangenschnittstelle ist PriorityQueue.

Prioritätswarteschlange

Eine PriorityQueue wird verwendet, wenn die Objekte nach Priorität verarbeitet werden sollen. Es ist bekannt, dass eine Warteschlange dem First-In-First-Out-Algorithmus folgt, aber manchmal müssen die Elemente der Warteschlange entsprechend ihrer Priorität verarbeitet werden, und in diesen Fällen wird diese Klasse verwendet. Die PriorityQueue basiert auf dem Prioritätsheap. Die Elemente der Prioritätswarteschlange werden gemäß der natürlichen Reihenfolge oder nach a geordnet Komparator Wird zum Zeitpunkt der Warteschlangenkonstruktion bereitgestellt, je nachdem, welcher Konstruktor verwendet wird.

Lassen Sie uns die Prioritätswarteschlange anhand eines Beispiels verstehen:

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

>

>

Ausgabe

10 10 15>

5. Und die Schnittstelle

Dies ist eine sehr geringfügige Variation von Zum Beispiel:

Deque ad = new ArrayDeque ();  Where T is the type of the object.>

Die Klasse, die die Deque-Schnittstelle implementiert, ist ArrayDeque.

ArrayDeque

Die im Sammlungsframework implementierte Klasse ArrayDeque bietet uns die Möglichkeit, ein in der Größe veränderbares Array anzuwenden. Dies ist eine besondere Art von Array, das wächst und es Benutzern ermöglicht, auf beiden Seiten der Warteschlange ein Element hinzuzufügen oder daraus zu entfernen. Für Array-Deques gelten keine Kapazitätsbeschränkungen und sie wachsen je nach Bedarf, um die Nutzung zu unterstützen.

Lassen Sie uns ArrayDeque anhand eines Beispiels verstehen:

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

>

>

Ausgabe

[10, 20, 30, 40, 50] [291, 564, 24, 14]>

6. Schnittstelle festlegen

Eine Menge ist eine ungeordnete Sammlung von Objekten, in der keine doppelten Werte gespeichert werden können. Diese Sammlung wird verwendet, wenn wir die Duplizierung der Objekte vermeiden und nur die eindeutigen Objekte speichern möchten. Diese Mengenschnittstelle wird von verschiedenen Klassen wie HashSet, TreeSet, LinkedHashSet usw. implementiert. Da alle Unterklassen die Menge implementieren, können wir mit jeder dieser Klassen ein Mengenobjekt instanziieren.

Zum Beispiel:

Set hs = new HashSet ();  Set lhs = new LinkedHashSet ();  Set ts = new TreeSet ();  Where T is the type of the object.>

Die folgenden Klassen implementieren die Set-Schnittstelle:

ich). HashSet

Die HashSet-Klasse ist eine inhärente Implementierung der Hash-Tabellen-Datenstruktur. Die Objekte, die wir in das HashSet einfügen, garantieren nicht, dass sie in derselben Reihenfolge eingefügt werden. Die Objekte werden anhand ihres Hashcodes eingefügt. Diese Klasse ermöglicht auch das Einfügen von NULL-Elementen. Lassen Sie uns HashSet anhand eines Beispiels verstehen:

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

>

>

Ausgabe

Very helpful Geeks For Is>

ii). LinkedHashSet

Ein LinkedHashSet ist einem HashSet sehr ähnlich. Der Unterschied besteht darin, dass eine doppelt verknüpfte Liste zum Speichern der Daten verwendet wird und die Reihenfolge der Elemente beibehalten wird.

Lassen Sie uns LinkedHashSet anhand eines Beispiels verstehen:

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

>

>

Ausgabe

Geeks For Is Very helpful>

7. Sortierte Set-Schnittstelle

Diese Schnittstelle ist der eingestellten Schnittstelle sehr ähnlich. Der einzige Unterschied besteht darin, dass diese Schnittstelle über zusätzliche Methoden verfügt, die die Reihenfolge der Elemente beibehalten. Die sortierte Set-Schnittstelle erweitert die Set-Schnittstelle und dient zur Verarbeitung der zu sortierenden Daten. Die Klasse, die diese Schnittstelle implementiert, ist TreeSet. Da diese Klasse das SortedSet implementiert, können wir mit dieser Klasse ein SortedSet-Objekt instanziieren.

Zum Beispiel:

SortedSet ts = new TreeSet ();  Where T is the type of the object.>

Die Klasse, die die Schnittstelle für sortierte Mengen implementiert, ist TreeSet.

TreeSet

Die TreeSet-Klasse verwendet einen Baum zur Speicherung. Die Reihenfolge der Elemente wird von einer Menge mithilfe ihrer natürlichen Reihenfolge beibehalten, unabhängig davon, ob ein expliziter Komparator bereitgestellt wird oder nicht. Dies muss mit equal konsistent sein, wenn die Set-Schnittstelle korrekt implementiert werden soll. Es kann auch von einem Comparator bestellt werden, der zu einem festgelegten Erstellungszeitpunkt bereitgestellt wird, je nachdem, welcher Konstruktor verwendet wird.

Lassen Sie uns TreeSet anhand eines Beispiels verstehen:

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

>

>

Ausgabe

For Geeks Is Very helpful>

8. Kartenschnittstelle

Eine Karte ist eine Datenstruktur, die das Schlüssel-Wert-Paar zum Zuordnen der Daten unterstützt. Diese Schnittstelle unterstützt keine doppelten Schlüssel, da derselbe Schlüssel nicht mehrere Zuordnungen haben kann, erlaubt jedoch doppelte Werte in verschiedenen Schlüsseln. Eine Karte ist nützlich, wenn Daten vorhanden sind und wir auf der Grundlage des Schlüssels Operationen ausführen möchten. Diese Kartenschnittstelle wird von verschiedenen Klassen wie implementiert HashMap , TreeMap usw. Da alle Unterklassen die Karte implementieren, können wir mit jeder dieser Klassen ein Kartenobjekt instanziieren.

Zum Beispiel:

Map hm = new HashMap ();  Map tm = new TreeMap ();   Where T is the type of the object.>

Die häufig verwendete Implementierung einer Map-Schnittstelle ist eine HashMap.

HashMap

HashMap stellt die grundlegende Implementierung der Map-Schnittstelle von Java bereit. Es speichert die Daten in (Schlüssel-, Wert-)Paaren. Um auf einen Wert in einer HashMap zuzugreifen, müssen wir seinen Schlüssel kennen. HashMap verwendet eine Technik namens Hashing. Hashing ist eine Technik zum Konvertieren eines großen Strings in einen kleinen String, der denselben String darstellt, sodass die Indizierungs- und Suchvorgänge schneller sind. HashSet verwendet HashMap auch intern.

Lassen Sie uns die HashMap anhand eines Beispiels verstehen:

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

>

>

Ausgabe

Value for 1 is Geeks 1 Geeks 2 For 3 Geeks>