De set-interface is aanwezig in het java.util-pakket en breidt het Verzamelinterface . Het is een ongeordende verzameling objecten waarin dubbele waarden niet kunnen worden opgeslagen. Het is een interface die de wiskundige set implementeert. Deze interface bevat de methoden die zijn overgenomen van de Collection-interface en voegt een functie toe die het invoegen van dubbele elementen beperkt. Er zijn twee interfaces die de set-implementatie uitbreiden, namelijk SortedSet en NavigableSet.
In de bovenstaande afbeelding breidt de navigeerbare set de interface van de gesorteerde set uit. Omdat een set de invoegvolgorde niet behoudt, biedt de navigeerbare setinterface de implementatie om door de set te navigeren. De klasse die de navigeerbare set implementeert is een TreeSet, een implementatie van een zelfbalancerende boom. Daarom biedt deze interface ons een manier om door deze boomstructuur te navigeren.
Verklaring: De Set-interface wordt gedeclareerd als:
public interface Set extends Collection>
Setobjecten maken
Omdat Set een koppel , kunnen er geen objecten worden gemaakt van het typeset. We hebben altijd een klasse nodig die deze lijst uitbreidt om een object te maken. En ook, na de introductie van Merkloos product in Java 1.5 is het mogelijk om het type object dat in de Set kan worden opgeslagen te beperken. Deze typeveilige set kan worden gedefinieerd als:
// Obj is the type of the object to be stored in Set Set set = new HashSet ();>
Laten we de methoden die aanwezig zijn in de Set-interface hieronder in tabelvorm hieronder als volgt bespreken:
| Methode | Beschrijving |
|---|---|
| toevoegen(element) | Deze methode wordt gebruikt om een specifiek element aan de set toe te voegen. De functie voegt het element alleen toe als het opgegeven element nog niet aanwezig is in de set. Anders retourneert de functie False als het element al aanwezig is in de set. |
| addAll(verzameling) | Deze methode wordt gebruikt om alle elementen uit de genoemde collectie aan de bestaande set toe te voegen. De elementen worden willekeurig toegevoegd zonder een specifieke volgorde te volgen. |
| duidelijk() | Deze methode wordt gebruikt om alle elementen uit de set te verwijderen, maar niet om de set te verwijderen. De referentie voor de set bestaat nog steeds. |
| bevat(element) | Deze methode wordt gebruikt om te controleren of een specifiek element aanwezig is in de Set of niet. |
| bevatAlles(verzameling) | Deze methode wordt gebruikt om te controleren of de set alle elementen bevat die aanwezig zijn in de gegeven collectie of niet. Deze methode retourneert true als de set alle elementen bevat en false als een van de elementen ontbreekt. |
| hashCode() | Deze methode wordt gebruikt om de hashCode-waarde voor dit exemplaar van de Set op te halen. Het retourneert een geheel getal dat de hashCode-waarde is voor dit exemplaar van de Set. |
| is leeg() | Deze methode wordt gebruikt om te controleren of de set leeg is of niet. |
| iterator() | Deze methode wordt gebruikt om het iterator van het stel. De elementen uit de set worden in willekeurige volgorde teruggegeven. |
| verwijder(element) | Deze methode wordt gebruikt om het gegeven element uit de set te verwijderen. Deze methode retourneert True als het opgegeven element aanwezig is in de set, anders retourneert het False. |
| verwijderAlles(verzameling) | Deze methode wordt gebruikt om alle elementen uit de collectie te verwijderen die in de set aanwezig zijn. Deze methode retourneert true als deze set is gewijzigd als gevolg van de aanroep. |
| behoudenAlles(verzameling) | Deze methode wordt gebruikt om alle elementen uit de set te behouden die in de betreffende collectie worden vermeld. Deze methode retourneert true als deze set is gewijzigd als gevolg van de aanroep. |
| maat() | Deze methode wordt gebruikt om de grootte van de set te bepalen. Dit retourneert een geheel getal dat het aantal elementen aangeeft. |
| toArray() | Deze methode wordt gebruikt om een array te vormen van dezelfde elementen als die van de Set. |
Illustratie: Voorbeeldprogramma om de set-interface te illustreren
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);> >}> }> |
>
>
afbeeldingen centreren in cssUitvoer
[Set, Example, Geeks, For]>
Bewerkingen op de set-interface
Met de set-interface kunnen gebruikers de wiskundige basisbewerkingen op de set uitvoeren. Laten we twee arrays nemen om deze basisbewerkingen te begrijpen. Stel set1 = [1, 3, 2, 4, 8, 9, 0] en set2 = [1, 3, 7, 5, 4, 0, 7, 5]. Dan zijn de mogelijke bewerkingen op de sets:
1. Kruispunt: Deze bewerking retourneert alle gemeenschappelijke elementen uit de gegeven twee sets. Voor de bovenstaande twee sets zou het snijpunt zijn:
Intersection = [0, 1, 3, 4]>
2. Unie: Deze bewerking voegt alle elementen in de ene set toe aan de andere. Voor de bovenstaande twee sets zou de unie zijn:
Union = [0, 1, 2, 3, 4, 5, 7, 8, 9]>
3. Verschil: Deze bewerking verwijdert alle waarden die aanwezig zijn in de ene set uit de andere set. Voor de bovenstaande twee sets zou het verschil zijn:
Difference = [2, 8, 9]>
Laten we nu de volgende bewerkingen, zoals hierboven gedefinieerd, als volgt implementeren:
Voorbeeld:
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);> >}> }> |
>
>Uitvoer
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]>
Verschillende bewerkingen uitvoeren op SortedSet
Na de introductie van Merkloos product in Java 1.5 is het mogelijk om het type object dat in de Set kan worden opgeslagen te beperken. Omdat Set een interface is, kan deze alleen worden gebruikt met een klasse die deze interface implementeert. HashSet is een van de veelgebruikte klassen die de Set-interface implementeert. Laten we nu eens kijken hoe we een paar veelgebruikte bewerkingen op de HashSet kunnen uitvoeren. We gaan de volgende bewerkingen als volgt uitvoeren:
- Elementen toevoegen
- Toegang tot elementen
- Elementen verwijderen
- Itererende elementen
- Itereren door Set
Laten we deze operaties nu als volgt afzonderlijk bespreken:
Bewerkingen 1: Elementen toevoegen
Om een element aan de Set toe te voegen, kunnen we de add() methode . De invoegopdracht blijft echter niet behouden in de set. Intern wordt voor elk element een hash gegenereerd en worden de waarden opgeslagen met betrekking tot de gegenereerde hash. de waarden worden vergeleken en in oplopende volgorde gesorteerd. We moeten er rekening mee houden dat dubbele elementen niet zijn toegestaan en dat alle dubbele elementen worden genegeerd. En ook worden nulwaarden geaccepteerd door de set.
Voorbeeld
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);> >}> }> |
>
>Uitvoer
[A, B, C]>
Operatie 2: Toegang tot de elementen
Als we na het toevoegen van de elementen toegang tot de elementen willen, kunnen we ingebouwde methoden gebruiken zoals contain() .
Voorbeeld
Java
a b c-nummers
// 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));> >}> }> |
>
>Uitvoer
Set is [A, B, C] Contains D false>
Operatie 3: De waarden verwijderen
De waarden kunnen uit de set worden verwijderd met behulp van de remove() methode.
Voorbeeld
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);> >}> }> |
>
>Uitvoer
Initial HashSet [A, B, C, D, E] After removing element [A, C, D, E]>
Operatie 4: Itereren door de set
Er zijn verschillende manieren om de set te doorlopen. De bekendste is het gebruik van de verbeterde for-lus.
Voorbeeld
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();> >}> }> |
>
>Uitvoer
A, B, C, D, E,>
Klassen die de Set-interface in Java Collections implementeren, kunnen als volgt gemakkelijk worden waargenomen in de onderstaande afbeelding en worden als volgt weergegeven:
- HashSet
- EnumSet
- GekoppeldeHashSet
- BoomSet
Klas 1: HashSet
HashSet-klasse die is geïmplementeerd in de verzamelkader is een inherente implementatie van de Voorbeeld
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());> >}> }> |
>
>Uitvoer
[South Africa, Australia, India] Set after removing Australia:[South Africa, India] Iterating over set: South Africa India>
Klasse 2: EnumSet
EnumSet-klasse die is geïmplementeerd in de collecties raamwerk is een van de gespecialiseerde implementaties van de Set-interface voor gebruik met de opsommingstype . Het is een krachtige set-implementatie, veel sneller dan HashSet. Alle elementen in een enumset moeten afkomstig zijn van één enkel opsommingstype dat wordt opgegeven wanneer de set expliciet of impliciet wordt gemaakt. Laten we eens kijken hoe we een set-object kunnen maken met behulp van deze klasse.
Voorbeeld
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);> >}> }> |
>
>Uitvoer
Set 1: [CODE, LEARN, CONTRIBUTE, QUIZ]>
Klasse 3: GekoppeldeHashSet
LinkedHashSet-klasse die is geïmplementeerd in de collecties raamwerk is een geordende versie van HashSet die een dubbel gekoppelde lijst bijhoudt voor alle elementen. Wanneer de iteratievolgorde moet worden gehandhaafd, wordt deze klasse gebruikt. Bij het doorlopen van een HashSet is de volgorde onvoorspelbaar, terwijl een LinkedHashSet ons de elementen laat doorlopen in de volgorde waarin ze zijn ingevoegd. Laten we eens kijken hoe we met deze klasse een set-object kunnen maken.
Voorbeeld
Java
verwijder hoekige cli
// 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());> >}> }> |
>
>Uitvoer
[India, Australia, South Africa] Set after removing Australia:[India, South Africa] Iterating over set: India South Africa>
Klasse 4: BoomSet
TreeSet-klasse die is geïmplementeerd in de collecties raamwerk en implementatie van de SortedSet Interface en SortedSet breidt de Set Interface uit. Het gedraagt zich als een eenvoudige set, met de uitzondering dat het elementen in een gesorteerd formaat opslaat. TreeSet gebruikt een boomdatastructuur voor opslag. Objecten worden in gesorteerde, oplopende volgorde opgeslagen. Maar we kunnen in aflopende volgorde herhalen met behulp van de methode TreeSet.descendingIterator(). Laten we eens kijken hoe we met deze klasse een set-object kunnen maken.
Voorbeeld
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());> >}> }> |
>
>Uitvoer
[Australia, India, South Africa] Set after removing Australia:[India, South Africa] Iterating over set: India South Africa>