La interfície set està present al paquet java.util i amplia el fitxer Interfície de col·lecció . És una col·lecció no ordenada d'objectes en què no es poden emmagatzemar valors duplicats. És una interfície que implementa el conjunt matemàtic. Aquesta interfície conté els mètodes heretats de la interfície Col·lecció i afegeix una característica que restringeix la inserció dels elements duplicats. Hi ha dues interfícies que amplien la implementació del conjunt, a saber, SortedSet i NavigableSet.
A la imatge de dalt, el conjunt navegable amplia la interfície del conjunt ordenat. Com que un conjunt no conserva l'ordre d'inserció, la interfície del conjunt navegable proporciona la implementació per navegar pel conjunt. La classe que implementa el conjunt navegable és un TreeSet que és una implementació d'un arbre d'autoequilibri. Per tant, aquesta interfície ens proporciona una manera de navegar per aquest arbre.
Declaració: La interfície Set es declara com:
public interface Set extends Collection>
Creació d'objectes conjunts
Com que Set és un interfície , no es poden crear objectes de la composició. Sempre necessitem una classe que ampliï aquesta llista per crear un objecte. I també, després de la introducció de Genèrics a Java 1.5, és possible restringir el tipus d'objecte que es pot emmagatzemar al conjunt. Aquest conjunt segur de tipus es pot definir com:
// Obj is the type of the object to be stored in Set Set set = new HashSet ();>
Parlem dels mètodes presents a la interfície Set que es proporciona a continuació en un format tabular de la següent manera:
| Mètode | Descripció |
|---|---|
| afegir (element) | Aquest mètode s'utilitza per afegir un element específic al conjunt. La funció afegeix l'element només si l'element especificat ja no està present al conjunt, sinó la funció retorna False si l'element ja està present al conjunt. |
| addAll (col·lecció) | Aquest mètode s'utilitza per afegir tots els elements de la col·lecció esmentada al conjunt existent. Els elements s'afegeixen aleatòriament sense seguir cap ordre específic. |
| clar () | Aquest mètode s'utilitza per eliminar tots els elements del conjunt però no eliminar el conjunt. La referència del conjunt encara existeix. |
| conté (element) | Aquest mètode s'utilitza per comprovar si un element específic està present al conjunt o no. |
| conté tot (col·lecció) | Aquest mètode s'utilitza per comprovar si el conjunt conté tots els elements presents a la col·lecció donada o no. Aquest mètode retorna true si el conjunt conté tots els elements i retorna false si falta algun dels elements. |
| hashCode() | Aquest mètode s'utilitza per obtenir el valor hashCode per a aquesta instància del conjunt. Retorna un valor enter que és el valor hashCode per a aquesta instància del conjunt. |
| està buit() | Aquest mètode s'utilitza per comprovar si el conjunt està buit o no. |
| iterador() | Aquest mètode s'utilitza per retornar el iterador del conjunt. Els elements del conjunt es retornen en un ordre aleatori. |
| eliminar (element) | Aquest mètode s'utilitza per eliminar l'element donat del conjunt. Aquest mètode retorna True si l'element especificat està present al conjunt, en cas contrari retorna False. |
| removeAll (col·lecció) | Aquest mètode s'utilitza per eliminar tots els elements de la col·lecció que estan presents al conjunt. Aquest mètode retorna true si aquest conjunt ha canviat com a resultat de la trucada. |
| retainAll (col·lecció) | Aquest mètode s'utilitza per retenir tots els elements del conjunt que s'esmenten a la col·lecció donada. Aquest mètode retorna true si aquest conjunt ha canviat com a resultat de la trucada. |
| mida () | Aquest mètode s'utilitza per obtenir la mida del conjunt. Això retorna un valor enter que indica el nombre d'elements. |
| toArray() | Aquest mètode s'utilitza per formar una matriu dels mateixos elements que el del conjunt. |
Il·lustració: Programa de mostra per il·lustrar la interfície del conjunt
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);> >}> }> |
>
>Sortida
[Set, Example, Geeks, For]>
Operacions a la interfície Set
La interfície del conjunt permet als usuaris realitzar l'operació matemàtica bàsica al conjunt. Prenem dues matrius per entendre aquestes operacions bàsiques. Sigui conjunt1 = [1, 3, 2, 4, 8, 9, 0] i conjunt2 = [1, 3, 7, 5, 4, 0, 7, 5]. Aleshores les operacions possibles sobre els conjunts són:
1. Intersecció: Aquesta operació retorna tots els elements comuns dels dos conjunts donats. Per als dos conjunts anteriors, la intersecció seria:
Intersection = [0, 1, 3, 4]>
2. Unió: Aquesta operació afegeix tots els elements d'un conjunt amb l'altre. Per als dos conjunts anteriors, la unió seria:
Union = [0, 1, 2, 3, 4, 5, 7, 8, 9]>
3. Diferència: Aquesta operació elimina tots els valors presents en un conjunt de l'altre conjunt. Per als dos conjunts anteriors, la diferència seria:
Difference = [2, 8, 9]>
Ara anem a implementar les operacions següents tal com s'ha definit anteriorment de la següent manera:
Exemple:
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);> >}> }> |
string jsonobject
>
>Sortida
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]>
Realització de diverses operacions a SortedSet
Després de la introducció de Genèrics a Java 1.5, és possible restringir el tipus d'objecte que es pot emmagatzemar al conjunt. Com que Set és una interfície, només es pot utilitzar amb una classe que implementi aquesta interfície. HashSet és una de les classes àmpliament utilitzades que implementa la interfície Set. Ara, vegem com realitzar algunes operacions d'ús freqüent al HashSet. Anem a realitzar les operacions següents de la següent manera:
afegint cadenes java
- Afegint elements
- Elements d'accés
- Eliminació d'elements
- Elements iterants
- Iterant a través de Set
Ara analitzem aquestes operacions individualment de la següent manera:
Operacions 1: Afegir Elements
Per afegir un element al conjunt, podem utilitzar el mètode add(). . Tanmateix, l'ordre d'inserció no es conserva al conjunt. Internament, per a cada element, es genera un hash i s'emmagatzemen els valors respecte al hash generat. els valors es comparen i s'ordenen en ordre ascendent. Hem de tenir una nota que no es permeten elements duplicats i que s'ignoren tots els elements duplicats. I també, els valors nuls són acceptats pel conjunt.
Exemple
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);> >}> }> |
>
>Sortida
[A, B, C]>
Operació 2: Accés als elements
Després d'afegir els elements, si volem accedir als elements, podem utilitzar mètodes integrats com contains() .
Exemple
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));> >}> }> |
>
>Sortida
Set is [A, B, C] Contains D false>
Operació 3: Eliminació dels valors
Els valors es poden eliminar del conjunt mitjançant el mètode remove() .
Exemple
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);> >}> }> |
>
>Sortida
Initial HashSet [A, B, C, D, E] After removing element [A, C, D, E]>
Operació 4: Iterant pel conjunt
Hi ha diverses maneres d'iterar a través del conjunt. El més famós és utilitzar el bucle for millorat.
Exemple
Java
en Java regex
// 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();> >}> }> |
>
>Sortida
A, B, C, D, E,>
Les classes que implementen la interfície Set a les col·leccions Java es poden percebre fàcilment des de la imatge següent i s'enumeren de la següent manera:
- HashSet
- EnumSet
- LinkedHashSet
- Conjunt d'arbres
Classe 1: HashSet
Classe HashSet que s'implementa al fitxer marc de recollida és una implementació inherent de la Exemple
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());> >}> }> |
>
>Sortida
[South Africa, Australia, India] Set after removing Australia:[South Africa, India] Iterating over set: South Africa India>
Classe 2: EnumSet
Classe EnumSet que s'implementa al fitxer marc de col·leccions és una de les implementacions especialitzades de la interfície Set per utilitzar amb el tipus d'enumeració . És una implementació de conjunt d'alt rendiment, molt més ràpid que HashSet. Tots els elements d'un conjunt d'enumeració han de provenir d'un únic tipus d'enumeració que s'especifica quan el conjunt es crea de manera explícita o implícita. Vegem com crear un objecte conjunt amb aquesta classe.
Exemple
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);> >}> }> |
>
>Sortida
Set 1: [CODE, LEARN, CONTRIBUTE, QUIZ]>
Classe 3: LinkedHashSet
Classe LinkedHashSet que s'implementa al fitxer marc de col·leccions és una versió ordenada de HashSet que manté una llista doblement enllaçada entre tots els elements. Quan cal mantenir l'ordre d'iteració, s'utilitza aquesta classe. En iterar a través d'un HashSet l'ordre és impredictible, mentre que un LinkedHashSet ens permet iterar a través dels elements en l'ordre en què s'han inserit. Vegem com crear un objecte conjunt amb aquesta classe.
Exemple
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());> >}> }> |
>
>Sortida
[India, Australia, South Africa] Set after removing Australia:[India, South Africa] Iterating over set: India South Africa>
Classe 4: Conjunt d'arbres
Classe TreeSet que s'implementa al fitxer marc de col·leccions i la implementació de la Interfície SortedSet i SortedSet amplia la Interfície Set. Es comporta com un conjunt senzill amb l'excepció que emmagatzema elements en un format ordenat. TreeSet utilitza una estructura de dades d'arbre per a l'emmagatzematge. Els objectes s'emmagatzemen en ordre ascendent i ordenats. Però podem iterar en ordre descendent utilitzant el mètode TreeSet.descendingIterator(). Vegem com crear un objecte conjunt amb aquesta classe.
Exemple
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());> >}> }> |
inicialització de la llista python
>
>Sortida
[Australia, India, South Africa] Set after removing Australia:[India, South Africa] Iterating over set: India South Africa>