Die Set-Schnittstelle ist im Paket java.util vorhanden und erweitert das Sammlungsschnittstelle . Es handelt sich um eine ungeordnete Sammlung von Objekten, in der keine doppelten Werte gespeichert werden können. Es handelt sich um eine Schnittstelle, die den mathematischen Satz implementiert. Diese Schnittstelle enthält die von der Collection-Schnittstelle geerbten Methoden und fügt eine Funktion hinzu, die das Einfügen der doppelten Elemente einschränkt. Es gibt zwei Schnittstellen, die die Set-Implementierung erweitern, nämlich SortedSet und NavigableSet .
Im obigen Bild erweitert der navigierbare Satz die Schnittstelle für sortierte Sätze. Da ein Set die Einfügereihenfolge nicht beibehält, bietet die navigierbare Set-Schnittstelle die Implementierung zum Navigieren durch das Set. Die Klasse, die den navigierbaren Satz implementiert, ist ein TreeSet, das eine Implementierung eines selbstausgleichenden Baums ist. Daher bietet uns diese Schnittstelle eine Möglichkeit, durch diesen Baum zu navigieren.
Erklärung: Die Set-Schnittstelle ist wie folgt deklariert:
public interface Set extends Collection>
Set-Objekte erstellen
Da Set ein ist Schnittstelle Aus dem Schriftsatz können keine Objekte erstellt werden. Wir benötigen immer eine Klasse, die diese Liste erweitert, um ein Objekt zu erstellen. Und auch nach der Einführung von Generika In Java 1.5 ist es möglich, den Objekttyp einzuschränken, der im Set gespeichert werden kann. Dieser typsichere Satz kann wie folgt definiert werden:
// Obj is the type of the object to be stored in Set Set set = new HashSet ();>
Lassen Sie uns die in der unten bereitgestellten Set-Schnittstelle vorhandenen Methoden in tabellarischer Form wie folgt besprechen:
| Methode | Beschreibung |
|---|---|
| hinzufügen(Element) | Mit dieser Methode wird der Menge ein bestimmtes Element hinzugefügt. Die Funktion fügt das Element nur hinzu, wenn das angegebene Element noch nicht in der Menge vorhanden ist. Andernfalls gibt die Funktion „False“ zurück, wenn das Element bereits in der Menge vorhanden ist. |
| addAll(collection) | Mit dieser Methode werden alle Elemente aus der genannten Sammlung an die vorhandene Menge angehängt. Die Elemente werden zufällig hinzugefügt, ohne eine bestimmte Reihenfolge einzuhalten. |
| klar() | Mit dieser Methode werden alle Elemente aus der Menge entfernt, die Menge jedoch nicht gelöscht. Die Referenz für den Satz existiert noch. |
| enthält(Element) | Mit dieser Methode wird überprüft, ob ein bestimmtes Element im Set vorhanden ist oder nicht. |
| enthältAlle(Sammlung) | Mit dieser Methode wird überprüft, ob die Menge alle in der angegebenen Sammlung vorhandenen Elemente enthält oder nicht. Diese Methode gibt true zurück, wenn die Menge alle Elemente enthält, und false, wenn eines der Elemente fehlt. |
| Hash-Code() | Diese Methode wird verwendet, um den HashCode-Wert für diese Instanz des Sets abzurufen. Es gibt einen ganzzahligen Wert zurück, der der HashCode-Wert für diese Instanz des Sets ist. |
| ist leer() | Mit dieser Methode wird überprüft, ob die Menge leer ist oder nicht. |
| Iterator() | Diese Methode wird verwendet, um die zurückzugeben Iterator des Sets. Die Elemente aus der Menge werden in zufälliger Reihenfolge zurückgegeben. |
| (Element) entfernen | Mit dieser Methode wird das angegebene Element aus der Menge entfernt. Diese Methode gibt „True“ zurück, wenn das angegebene Element im Set vorhanden ist, andernfalls gibt sie „False“ zurück. |
| RemoveAll(Sammlung) | Mit dieser Methode werden alle im Set vorhandenen Elemente aus der Sammlung entfernt. Diese Methode gibt true zurück, wenn sich dieser Satz durch den Aufruf geändert hat. |
| keepAll(collection) | Diese Methode wird verwendet, um alle Elemente aus der Menge beizubehalten, die in der angegebenen Sammlung erwähnt werden. Diese Methode gibt true zurück, wenn sich dieser Satz durch den Aufruf geändert hat. |
| Größe() | Diese Methode wird verwendet, um die Größe des Satzes zu ermitteln. Dies gibt einen ganzzahligen Wert zurück, der die Anzahl der Elemente angibt. |
| toArray() | Diese Methode wird verwendet, um ein Array mit denselben Elementen wie das Set zu bilden. |
Illustration: Beispielprogramm zum Illustrieren der Set-Schnittstelle
Java
// Java program Illustrating Set Interface> > // Importing utility classes> import> java.util.*;> > // Main class> public> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> >// Demonstrating Set using HashSet> >// Declaring object of type String> >Set hash_Set =>new> HashSet();> > >// Adding elements to the Set> >// using add() method> >hash_Set.add(>'Geeks'>);> >hash_Set.add(>'For'>);> >hash_Set.add(>'Geeks'>);> >hash_Set.add(>'Example'>);> >hash_Set.add(>'Set'>);> > >// Printing elements of HashSet object> >System.out.println(hash_Set);> >}> }> |
>
>Ausgabe
[Set, Example, Geeks, For]>
Operationen auf der Set-Schnittstelle
Die Set-Schnittstelle ermöglicht es den Benutzern, grundlegende mathematische Operationen am Set durchzuführen. Nehmen wir zwei Arrays, um diese grundlegenden Operationen zu verstehen. Sei set1 = [1, 3, 2, 4, 8, 9, 0] und set2 = [1, 3, 7, 5, 4, 0, 7, 5]. Dann sind die möglichen Operationen auf den Mengen:
1. Kreuzung: Diese Operation gibt alle gemeinsamen Elemente aus den beiden gegebenen Mengen zurück. Für die beiden oben genannten Mengen wäre der Schnittpunkt:
Intersection = [0, 1, 3, 4]>
2. Gewerkschaft: Diese Operation fügt alle Elemente in einem Satz mit dem anderen hinzu. Für die beiden oben genannten Mengen wäre die Vereinigung:
Union = [0, 1, 2, 3, 4, 5, 7, 8, 9]>
3. Unterschied: Dieser Vorgang entfernt alle in einem Satz vorhandenen Werte aus dem anderen Satz. Für die beiden oben genannten Sätze wäre der Unterschied:
Difference = [2, 8, 9]>
Lassen Sie uns nun die folgenden Operationen wie oben definiert implementieren:
Beispiel:
Java
// Java Program Demonstrating Operations on the Set> // such as Union, Intersection and Difference operations> > // Importing all utility classes> import> java.util.*;> > // Main class> public> class> SetExample {> > >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of Set class> >// Declaring object of Integer type> >Set a =>new> HashSet();> > >// Adding all elements to List> >a.addAll(Arrays.asList(> >new> Integer[] {>1>,>3>,>2>,>4>,>8>,>9>,>0> }));> > >// Again declaring object of Set class> >// with reference to HashSet> >Set b =>new> HashSet();> > >b.addAll(Arrays.asList(> >new> Integer[] {>1>,>3>,>7>,>5>,>4>,>0>,>7>,>5> }));> > > >// To find union> >Set union =>new> HashSet(a);> >union.addAll(b);> >System.out.print(>'Union of the two Set'>);> >System.out.println(union);> > >// To find intersection> >Set intersection =>new> HashSet(a);> >intersection.retainAll(b);> >System.out.print(>'Intersection of the two Set'>);> >System.out.println(intersection);> > >// To find the symmetric difference> >Set difference =>new> HashSet(a);> >difference.removeAll(b);> >System.out.print(>'Difference of the two Set'>);> >System.out.println(difference);> >}> }> |
Pandas iterrows
>
>Ausgabe
Union of the two Set[0, 1, 2, 3, 4, 5, 7, 8, 9] Intersection of the two Set[0, 1, 3, 4] Difference of the two Set[2, 8, 9]>
Durchführen verschiedener Vorgänge für SortedSet
Nach der Einführung von Generika In Java 1.5 ist es möglich, den Objekttyp einzuschränken, der im Set gespeichert werden kann. Da Set eine Schnittstelle ist, kann es nur mit einer Klasse verwendet werden, die diese Schnittstelle implementiert. HashSet ist eine der am häufigsten verwendeten Klassen, die die Set-Schnittstelle implementiert. Sehen wir uns nun an, wie man einige häufig verwendete Vorgänge am HashSet durchführt. Wir werden die folgenden Operationen wie folgt durchführen:
- Elemente hinzufügen
- Auf Elemente zugreifen
- Elemente entfernen
- Iterierende Elemente
- Durch Set iterieren
Lassen Sie uns nun diese Operationen einzeln wie folgt besprechen:
Operationen 1: Elemente hinzufügen
Um dem Set ein Element hinzuzufügen, können wir das verwenden add()-Methode . Die Einfügungsreihenfolge bleibt jedoch im Set nicht erhalten. Intern wird für jedes Element ein Hash generiert und die Werte werden in Bezug auf den generierten Hash gespeichert. Die Werte werden verglichen und in aufsteigender Reihenfolge sortiert. Wir müssen beachten, dass doppelte Elemente nicht zulässig sind und alle doppelten Elemente ignoriert werden. Außerdem werden vom Set Nullwerte akzeptiert.
Beispiel
Java
// Java Program Demonstrating Working of Set by> // Adding elements using add() method> > // Importing all utility classes> import> java.util.*;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> >// Creating an object of Set and> >// declaring object of type String> >Set hs =>new> HashSet();> > >// Adding elements to above object> >// using add() method> >hs.add(>'B'>);> >hs.add(>'B'>);> >hs.add(>'C'>);> >hs.add(>'A'>);> > >// Printing the elements inside the Set object> >System.out.println(hs);> >}> }> |
>
>Ausgabe
[A, B, C]>
Vorgang 2: Zugriff auf die Elemente
Wenn wir nach dem Hinzufügen der Elemente auf die Elemente zugreifen möchten, können wir integrierte Methoden wie contains() verwenden.
Beispiel
Java
// Java code to demonstrate Working of Set by> // Accessing the Elements of the Set object> > // Importing all utility classes> import> java.util.*;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> >// Creating an object of Set and> >// declaring object of type String> >Set hs =>new> HashSet();> > >// Elements are added using add() method> >// Later onwards we will show accessing the same> > >// Custom input elements> >hs.add(>'A'>);> >hs.add(>'B'>);> >hs.add(>'C'>);> >hs.add(>'A'>);> > >// Print the Set object elements> >System.out.println(>'Set is '> + hs);> > >// Declaring a string> >String check =>'D'>;> > >// Check if the above string exists in> >// the SortedSet or not> >// using contains() method> >System.out.println(>'Contains '> + check +>' '> >+ hs.contains(check));> >}> }> |
>
>Ausgabe
Set is [A, B, C] Contains D false>
Vorgang 3: Entfernen der Werte
Die Werte können mit der Methode „remove()“ aus dem Set entfernt werden.
Beispiel
Java
// Java Program Demonstrating Working of Set by> // Removing Element/s from the Set> > // Importing all utility classes> import> java.util.*;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> >// Declaring object of Set of type String> >Set hs =>new> HashSet();> > >// Elements are added> >// using add() method> > >// Custom input elements> >hs.add(>'A'>);> >hs.add(>'B'>);> >hs.add(>'C'>);> >hs.add(>'B'>);> >hs.add(>'D'>);> >hs.add(>'E'>);> > >// Printing initial Set elements> >System.out.println(>'Initial HashSet '> + hs);> > >// Removing custom element> >// using remove() method> >hs.remove(>'B'>);> > >// Printing Set elements after removing an element> >// and printing updated Set elements> >System.out.println(>'After removing element '> + hs);> >}> }> |
>
>Ausgabe
Initial HashSet [A, B, C, D, E] After removing element [A, C, D, E]>
Vorgang 4: Durch das Set iterieren
Es gibt verschiedene Möglichkeiten, das Set zu durchlaufen. Die bekannteste Variante ist die Verwendung der erweiterten for-Schleife.
Beispiel
Java
// Java Program to Demonstrate Working of Set by> // Iterating through the Elements> > // Importing utility classes> import> java.util.*;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> >// Creating object of Set and declaring String type> >Set hs =>new> HashSet();> > >// Adding elements to Set> >// using add() method> > >// Custom input elements> >hs.add(>'A'>);> >hs.add(>'B'>);> >hs.add(>'C'>);> >hs.add(>'B'>);> >hs.add(>'D'>);> >hs.add(>'E'>);> > >// Iterating through the Set> >// via for-each loop> >for> (String value : hs)> > >// Printing all the values inside the object> >System.out.print(value +>', '>);> > >System.out.println();> >}> }> |
>
>Ausgabe
A, B, C, D, E,>
Klassen, die die Set-Schnittstelle in Java-Sammlungen implementieren, sind anhand der folgenden Abbildung leicht zu erkennen und werden wie folgt aufgelistet:
- HashSet
- EnumSet
- LinkedHashSet
- TreeSet
Klasse 1: HashSet
HashSet-Klasse, die in implementiert ist Sammlungsrahmen ist eine inhärente Implementierung von Beispiel
Java
// Java program Demonstrating Creation of Set object> // Using the Hashset class> > // Importing utility classes> import> java.util.*;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> >// Creating object of Set of type String> >Set h =>new> HashSet();> > >// Adding elements into the HashSet> >// using add() method> > >// Custom input elements> >h.add(>'India'>);> >h.add(>'Australia'>);> >h.add(>'South Africa'>);> > >// Adding the duplicate element> >h.add(>'India'>);> > >// Displaying the HashSet> >System.out.println(h);> > >// Removing items from HashSet> >// using remove() method> >h.remove(>'Australia'>);> >System.out.println(>'Set after removing '> >+>'Australia:'> + h);> > >// Iterating over hash set items> >System.out.println(>'Iterating over set:'>);> > >// Iterating through iterators> >Iterator i = h.iterator();> > >// It holds true till there is a single element> >// remaining in the object> >while> (i.hasNext())> > >System.out.println(i.next());> >}> }> |
>
>Ausgabe
[South Africa, Australia, India] Set after removing Australia:[South Africa, India] Iterating over set: South Africa India>
Klasse 2: EnumSet
EnumSet-Klasse, die in implementiert ist Sammlungsrahmen ist eine der spezialisierten Implementierungen der Set-Schnittstelle zur Verwendung mit Aufzählungstyp . Es handelt sich um eine leistungsstarke Set-Implementierung, die viel schneller als HashSet ist. Alle Elemente in einem Aufzählungssatz müssen von einem einzigen Aufzählungstyp stammen, der beim Erstellen des Satzes entweder explizit oder implizit angegeben wird. Sehen wir uns an, wie man mit dieser Klasse ein Set-Objekt erstellt.
Beispiel
Java
// Java program to demonstrate the> // creation of the set object> // using the EnumSet class> import> java.util.*;> > enum> Gfg { CODE, LEARN, CONTRIBUTE, QUIZ, MCQ }> ;> > public> class> GFG {> > >public> static> void> main(String[] args)> >{> >// Creating a set> >Set set1;> > >// Adding the elements> >set1 = EnumSet.of(Gfg.QUIZ, Gfg.CONTRIBUTE,> >Gfg.LEARN, Gfg.CODE);> > >System.out.println(>'Set 1: '> + set1);> >}> }> |
>
>Ausgabe
Set 1: [CODE, LEARN, CONTRIBUTE, QUIZ]>
Klasse 3: LinkedHashSet
LinkedHashSet-Klasse, die in der implementiert ist Sammlungsrahmen ist eine geordnete Version von HashSet, die eine doppelt verknüpfte Liste über alle Elemente hinweg verwaltet. Wenn die Iterationsreihenfolge beibehalten werden muss, wird diese Klasse verwendet. Beim Durchlaufen eines HashSets ist die Reihenfolge unvorhersehbar, während wir mit einem LinkedHashSet die Elemente in der Reihenfolge durchlaufen können, in der sie eingefügt wurden. Sehen wir uns an, wie man mit dieser Klasse ein Set-Objekt erstellt.
Beispiel
Java
// Java program to demonstrate the> // creation of Set object using> // the LinkedHashset class> import> java.util.*;> > class> GFG {> > >public> static> void> main(String[] args)> >{> >Set lh =>new> LinkedHashSet();> > >// Adding elements into the LinkedHashSet> >// using add()> >lh.add(>'India'>);> >lh.add(>'Australia'>);> >lh.add(>'South Africa'>);> > >// Adding the duplicate> >// element> >lh.add(>'India'>);> > >// Displaying the LinkedHashSet> >System.out.println(lh);> > >// Removing items from LinkedHashSet> >// using remove()> >lh.remove(>'Australia'>);> >System.out.println(>'Set after removing '> >+>'Australia:'> + lh);> > >// Iterating over linked hash set items> >System.out.println(>'Iterating over set:'>);> >Iterator i = lh.iterator();> >while> (i.hasNext())> >System.out.println(i.next());> >}> }> |
>
>Ausgabe
[India, Australia, South Africa] Set after removing Australia:[India, South Africa] Iterating over set: India South Africa>
Klasse 4: TreeSet
TreeSet-Klasse, die in implementiert ist Sammlungsrahmen und Implementierung der SortedSet-Schnittstelle und SortedSet erweitert die Set-Schnittstelle. Es verhält sich wie eine einfache Menge mit der Ausnahme, dass es Elemente in einem sortierten Format speichert. TreeSet verwendet eine Baumdatenstruktur zur Speicherung. Objekte werden in aufsteigender Reihenfolge sortiert gespeichert. Aber wir können mit der Methode TreeSet.descendingIterator() in absteigender Reihenfolge iterieren. Sehen wir uns an, wie man mit dieser Klasse ein Set-Objekt erstellt.
Beispiel
Java
// Java Program Demonstrating Creation of Set object> // Using the TreeSet class> > // Importing utility classes> import> java.util.*;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> >// Creating a Set object and declaring it of String> >// type> >// with reference to TreeSet> >Set ts =>new> TreeSet();> > >// Adding elements into the TreeSet> >// using add()> >ts.add(>'India'>);> >ts.add(>'Australia'>);> >ts.add(>'South Africa'>);> > >// Adding the duplicate> >// element> >ts.add(>'India'>);> > >// Displaying the TreeSet> >System.out.println(ts);> > >// Removing items from TreeSet> >// using remove()> >ts.remove(>'Australia'>);> >System.out.println(>'Set after removing '> >+>'Australia:'> + ts);> > >// Iterating over Tree set items> >System.out.println(>'Iterating over set:'>);> >Iterator i = ts.iterator();> > >while> (i.hasNext())> >System.out.println(i.next());> >}> }> |
>
np Nullen
>Ausgabe
[Australia, India, South Africa] Set after removing Australia:[India, South Africa] Iterating over set: India South Africa>