Set-gränssnittet finns i java.util-paketet och utökar Samlingsgränssnitt . Det är en oordnad samling objekt där dubbletter av värden inte kan lagras. Det är ett gränssnitt som implementerar den matematiska uppsättningen. Det här gränssnittet innehåller metoderna som ärvts från samlingsgränssnittet och lägger till en funktion som begränsar infogningen av dubblettelementen. Det finns två gränssnitt som utökar setimplementeringen, nämligen SortedSet och NavigableSet.
I bilden ovan utökar den navigerbara uppsättningen gränssnittet för sorterade uppsättningar. Eftersom en uppsättning inte behåller insättningsordningen, tillhandahåller det navigerbara uppsättningsgränssnittet implementeringen för att navigera genom uppsättningen. Klassen som implementerar den navigerbara uppsättningen är en TreeSet som är en implementering av ett självbalanserande träd. Därför ger detta gränssnitt oss ett sätt att navigera genom detta träd.
Deklaration: Set-gränssnittet deklareras som:
public interface Set extends Collection>
Skapa uppsättningsobjekt
Eftersom Set är en gränssnitt , objekt kan inte skapas av typen. Vi behöver alltid en klass som utökar denna lista för att kunna skapa ett objekt. Och även efter införandet av Generika i Java 1.5 är det möjligt att begränsa typen av objekt som kan lagras i setet. Denna typsäkra uppsättning kan definieras som:
// Obj is the type of the object to be stored in Set Set set = new HashSet ();>
Låt oss diskutera metoder som finns i Set-gränssnittet nedan i ett tabellformat nedan enligt följande:
| Metod | Beskrivning |
|---|---|
| add(element) | Denna metod används för att lägga till ett specifikt element till uppsättningen. Funktionen lägger bara till elementet om det angivna elementet inte redan finns i uppsättningen annars returnerar funktionen False om elementet redan finns i uppsättningen. |
| addAll (samling) | Denna metod används för att lägga till alla element från den nämnda samlingen till den befintliga uppsättningen. Elementen läggs till slumpmässigt utan att följa någon specifik ordning. |
| klar() | Denna metod används för att ta bort alla element från uppsättningen men inte ta bort uppsättningen. Referensen för uppsättningen finns fortfarande kvar. |
| innehåller(element) | Denna metod används för att kontrollera om ett specifikt element finns i uppsättningen eller inte. |
| innehåller alla (samling) | Denna metod används för att kontrollera om uppsättningen innehåller alla element som finns i den givna samlingen eller inte. Denna metod returnerar true om uppsättningen innehåller alla element och returnerar false om något av elementen saknas. |
| hash-kod() | Denna metod används för att få hashCode-värdet för denna instans av setet. Den returnerar ett heltalsvärde som är hashCode-värdet för denna instans av uppsättningen. |
| är tom() | Denna metod används för att kontrollera om uppsättningen är tom eller inte. |
| iterator() | Denna metod används för att returnera iterator av uppsättningen. Elementen från setet returneras i slumpmässig ordning. |
| remove(element) | Denna metod används för att ta bort det givna elementet från uppsättningen. Denna metod returnerar True om det angivna elementet finns i uppsättningen annars returnerar den False. |
| removeAll (samling) | Denna metod används för att ta bort alla element från samlingen som finns i uppsättningen. Denna metod returnerar sant om denna uppsättning ändras som ett resultat av anropet. |
| retainAll (samling) | Denna metod används för att behålla alla element från uppsättningen som nämns i den givna samlingen. Denna metod returnerar sant om denna uppsättning ändras som ett resultat av anropet. |
| storlek() | Denna metod används för att få storleken på uppsättningen. Detta returnerar ett heltalsvärde som anger antalet element. |
| toArray() | Denna metod används för att bilda en array av samma element som den i Setet. |
Illustration: Exempelprogram för att illustrera Set-gränssnittet
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);> >}> }> |
>
>Produktion
[Set, Example, Geeks, For]>
Operationer på Set Interface
Set-gränssnittet låter användarna utföra den grundläggande matematiska operationen på setet. Låt oss ta två arrayer för att förstå dessa grundläggande operationer. Låt set1 = [1, 3, 2, 4, 8, 9, 0] och set2 = [1, 3, 7, 5, 4, 0, 7, 5]. Sedan är de möjliga operationerna på uppsättningarna:
1. Korsning: Denna operation returnerar alla gemensamma element från de givna två uppsättningarna. För ovanstående två uppsättningar skulle skärningspunkten vara:
Intersection = [0, 1, 3, 4]>
2. Union: Denna operation lägger till alla element i en uppsättning med den andra. För de två ovanstående uppsättningarna skulle facket vara:
Union = [0, 1, 2, 3, 4, 5, 7, 8, 9]>
3. Skillnad: Denna operation tar bort alla värden som finns i en uppsättning från den andra uppsättningen. För de två ovanstående uppsättningarna skulle skillnaden vara:
Difference = [2, 8, 9]>
Låt oss nu implementera följande operationer enligt definitionen ovan enligt följande:
Exempel:
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);> >}> }> |
>
>Produktion
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]>
Utföra olika operationer på SortedSet
Efter införandet av Generika i Java 1.5 är det möjligt att begränsa typen av objekt som kan lagras i setet. Eftersom Set är ett gränssnitt kan det endast användas med en klass som implementerar detta gränssnitt. HashSet är en av de mycket använda klasserna som implementerar Set-gränssnittet. Låt oss nu se hur man utför några ofta använda operationer på HashSet. Vi kommer att utföra följande operationer enligt följande:
vad är klustring
- Lägga till element
- Tillgång till element
- Ta bort element
- Itererande element
- Itererar genom Set
Låt oss nu diskutera dessa operationer individuellt enligt följande:
Operation 1: Lägga till element
För att lägga till ett element till setet kan vi använda add() metod . Insättningsordningen behålls dock inte i uppsättningen. Internt, för varje element, genereras en hash och värdena lagras med avseende på den genererade hashen. värdena jämförs och sorteras i stigande ordning. Vi måste notera att duplicerade element inte är tillåtna och alla duplicerade element ignoreras. Och även nollvärden accepteras av setet.
Exempel
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);> >}> }> |
>
>Produktion
[A, B, C]>
Operation 2: Tillgång till elementen
Efter att ha lagt till elementen, om vi vill komma åt elementen, kan vi använda inbyggda metoder som contains() .
Exempel
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));> >}> }> |
>
>Produktion
anslutningar i java
Set is [A, B, C] Contains D false>
Operation 3: Ta bort värdena
Värdena kan tas bort från Set med metoden remove() .
Exempel
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);> >}> }> |
>
>Produktion
Initial HashSet [A, B, C, D, E] After removing element [A, C, D, E]>
Operation 4: Itererar genom setet
Det finns olika sätt att iterera genom setet. Den mest kända är att använda den förbättrade för loop.
Exempel
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();> >}> }> |
>
>Produktion
A, B, C, D, E,>
Klasser som implementerar Set-gränssnittet i Java Collections kan enkelt uppfattas från bilden nedan enligt följande och listas enligt följande:
- HashSet
- EnumSet
- LinkedHashSet
- Träduppsättning
Klass 1: HashSet
HashSet-klassen som är implementerad i insamlingsram är en inneboende implementering av Exempel
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());> >}> }> |
>
>Produktion
[South Africa, Australia, India] Set after removing Australia:[South Africa, India] Iterating over set: South Africa India>
Klass 2: EnumSet
EnumSet-klassen som är implementerad i samlingsram är en av de specialiserade implementeringarna av Set-gränssnittet för användning med uppräkningstyp . Det är en högpresterande setimplementering, mycket snabbare än HashSet. Alla element i en uppräkningsuppsättning måste komma från en enda uppräkningstyp som anges när uppsättningen skapas antingen explicit eller implicit. Låt oss se hur man skapar ett uppsättningsobjekt med den här klassen.
Exempel
Java
Skådespelerskan Sai Pallavi
// 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);> >}> }> |
>
>Produktion
Set 1: [CODE, LEARN, CONTRIBUTE, QUIZ]>
Klass 3: LinkedHashSet
LinkedHashSet-klassen som är implementerad i samlingsram är en ordnad version av HashSet som upprätthåller en dubbellänkad lista över alla element. När iterationsordningen behövs för att underhållas används denna klass. När man itererar genom ett HashSet är ordningen oförutsägbar, medan en LinkedHashSet låter oss iterera genom elementen i den ordning som de infogades. Låt oss se hur man skapar ett uppsättningsobjekt med den här klassen.
Exempel
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());> >}> }> |
>
>Produktion
[India, Australia, South Africa] Set after removing Australia:[India, South Africa] Iterating over set: India South Africa>
Klass 4: Träduppsättning
TreeSet-klassen som är implementerad i samlingsram och implementering av SortedSet Interface och SortedSet utökar Set Interface. Den beter sig som en enkel uppsättning med undantaget att den lagrar element i ett sorterat format. TreeSet använder en träddatastruktur för lagring. Objekt lagras i sorterad, stigande ordning. Men vi kan iterera i fallande ordning med metoden TreeSet.descendingIterator(). Låt oss se hur man skapar ett uppsättningsobjekt med den här klassen.
Exempel
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());> >}> }> |
>
>Produktion
[Australia, India, South Africa] Set after removing Australia:[India, South Africa] Iterating over set: India South Africa>