L'interfaccia impostata è presente nel pacchetto java.util ed estende il file Interfaccia di raccolta . È una raccolta non ordinata di oggetti in cui non è possibile archiviare valori duplicati. È un'interfaccia che implementa il set matematico. Questa interfaccia contiene i metodi ereditati dall'interfaccia Collection e aggiunge una funzionalità che limita l'inserimento degli elementi duplicati. Esistono due interfacce che estendono l'implementazione del set, vale a dire SortedSet e NavigableSet .
Nell'immagine sopra, il set navigabile estende l'interfaccia del set ordinato. Poiché un set non mantiene l'ordine di inserimento, l'interfaccia del set navigabile fornisce l'implementazione per navigare nel set. La classe che implementa il set navigabile è una TreeSet che è un'implementazione di un albero autobilanciante. Pertanto, questa interfaccia ci fornisce un modo per navigare attraverso questo albero.
Dichiarazione: L'interfaccia Set è dichiarata come:
public interface Set extends Collection>
Creazione di oggetti impostati
Poiché Set è un interfaccia , gli oggetti non possono essere creati dalla composizione. Abbiamo sempre bisogno di una classe che estenda questo elenco per creare un oggetto. E inoltre, dopo l'introduzione di Generici in Java 1.5 è possibile limitare il tipo di oggetto che può essere memorizzato nel Set. Questo set indipendente dai tipi può essere definito come:
// Obj is the type of the object to be stored in Set Set set = new HashSet ();>
Parliamo dei metodi presenti nell'interfaccia Set fornita di seguito in un formato tabellare come segue:
| Metodo | Descrizione |
|---|---|
| aggiungi(elemento) | Questo metodo viene utilizzato per aggiungere un elemento specifico al set. La funzione aggiunge l'elemento solo se l'elemento specificato non è già presente nel set altrimenti la funzione restituisce False se l'elemento è già presente nel Set. |
| aggiungiTutto(raccolta) | Questo metodo viene utilizzato per aggiungere tutti gli elementi della raccolta menzionata al set esistente. Gli elementi vengono aggiunti in modo casuale senza seguire alcun ordine specifico. |
| chiaro() | Questo metodo viene utilizzato per rimuovere tutti gli elementi dall'insieme ma non eliminare l'insieme. Il riferimento per il set esiste ancora. |
| contiene(elemento) | Questo metodo viene utilizzato per verificare se un determinato elemento è presente o meno nel Set. |
| contieneTutto(raccolta) | Questo metodo viene utilizzato per verificare se l'insieme contiene o meno tutti gli elementi presenti nella raccolta data. Questo metodo restituisce true se l'insieme contiene tutti gli elementi e restituisce false se manca uno qualsiasi degli elementi. |
| codice hash() | Questo metodo viene utilizzato per ottenere il valore hashCode per questa istanza del Set. Restituisce un valore intero che è il valore hashCode per questa istanza del Set. |
| è vuoto() | Questo metodo viene utilizzato per verificare se il set è vuoto o meno. |
| iteratore() | Questo metodo viene utilizzato per restituire il file iteratore dell'insieme. Gli elementi del set vengono restituiti in ordine casuale. |
| rimuovi(elemento) | Questo metodo viene utilizzato per rimuovere l'elemento specificato dall'insieme. Questo metodo restituisce True se l'elemento specificato è presente nel Set altrimenti restituisce False. |
| rimuovi tutto(raccolta) | Questo metodo viene utilizzato per rimuovere dalla collezione tutti gli elementi presenti nell'insieme. Questo metodo restituisce true se questo set è cambiato come risultato della chiamata. |
| keepAll(raccolta) | Questo metodo viene utilizzato per conservare tutti gli elementi dell'insieme menzionati nella raccolta data. Questo metodo restituisce true se questo set è cambiato come risultato della chiamata. |
| misurare() | Questo metodo viene utilizzato per ottenere la dimensione del set. Ciò restituisce un valore intero che indica il numero di elementi. |
| toArray() | Questo metodo viene utilizzato per formare un array degli stessi elementi di quello del Set. |
Illustrazione: Programma di esempio per illustrare l'interfaccia del set
Giava
// 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);> >}> }> |
>
>Produzione
[Set, Example, Geeks, For]>
Operazioni sull'interfaccia Set
L'interfaccia del set consente agli utenti di eseguire le operazioni matematiche di base sul set. Prendiamo due array per comprendere queste operazioni di base. Sia set1 = [1, 3, 2, 4, 8, 9, 0] e set2 = [1, 3, 7, 5, 4, 0, 7, 5]. Allora le possibili operazioni sugli insiemi sono:
1. Intersezione: Questa operazione restituisce tutti gli elementi comuni dei due insiemi indicati. Per i due insiemi precedenti, l'intersezione sarebbe:
Intersection = [0, 1, 3, 4]>
2. Unione: Questa operazione aggiunge tutti gli elementi di un set con l'altro. Per i due insiemi precedenti, l'unione sarebbe:
Union = [0, 1, 2, 3, 4, 5, 7, 8, 9]>
3. Differenza: Questa operazione rimuove tutti i valori presenti in un insieme dall'altro insieme. Per i due set precedenti, la differenza sarebbe:
Difference = [2, 8, 9]>
Ora implementiamo le seguenti operazioni come sopra definite come segue:
Esempio:
Giava
// 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);> >}> }> |
>
>Produzione
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]>
Esecuzione di varie operazioni su SortedSet
Dopo l'introduzione di Generici in Java 1.5 è possibile limitare il tipo di oggetto che può essere memorizzato nel Set. Poiché Set è un'interfaccia, può essere utilizzata solo con una classe che implementa questa interfaccia. HashSet è una delle classi ampiamente utilizzate che implementa l'interfaccia Set. Ora vediamo come eseguire alcune operazioni utilizzate di frequente su HashSet. Eseguiremo le seguenti operazioni come segue:
- Aggiunta di elementi
- Accesso agli elementi
- Rimozione di elementi
- Elementi iterativi
- Iterazione attraverso Set
Consideriamo ora queste operazioni singolarmente nel modo seguente:
Operazioni 1: Aggiunta di elementi
Per aggiungere un elemento al Set possiamo usare il metodo add() . Tuttavia, l'ordine di inserimento non viene mantenuto nel Set. Internamente, per ogni elemento, viene generato un hash e i valori vengono memorizzati rispetto all'hash generato. i valori vengono confrontati e ordinati in ordine crescente. Dobbiamo tenere presente che gli elementi duplicati non sono consentiti e tutti gli elementi duplicati vengono ignorati. Inoltre, i valori Null sono accettati dal Set.
Esempio
Giava
// 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);> >}> }> |
>
>Produzione
[A, B, C]>
Operazione 2: Accesso agli elementi
Dopo aver aggiunto gli elementi, se desideriamo accedere agli elementi, possiamo utilizzare metodi integrati come contiene() .
Esempio
Giava
// 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));> >}> }> |
>
>Produzione
Set is [A, B, C] Contains D false>
Operazione 3: Rimozione dei valori
I valori possono essere rimossi dal Set utilizzando il metodo Remove() .
Esempio
Giava
// 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);> >}> }> |
>
>Produzione
Initial HashSet [A, B, C, D, E] After removing element [A, C, D, E]>
Operazione 4: Iterazione attraverso il set
Esistono vari modi per scorrere il Set. Il più famoso è usare il ciclo for potenziato.
Esempio
Giava
// 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();> >}> }> |
>
>Produzione
A, B, C, D, E,>
Le classi che implementano l'interfaccia Set nelle Java Collections possono essere facilmente percepite dall'immagine sottostante come segue e sono elencate come segue:
- HashSet
- EnumSet
- LinkedHashSet
- Set di alberi
Classe 1: HashSet
Classe HashSet implementata nel file quadro di raccolta è un'implementazione intrinseca di Esempio
Giava
// 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());> >}> }> |
>
>Produzione
[South Africa, Australia, India] Set after removing Australia:[South Africa, India] Iterating over set: South Africa India>
Classe 2: EnumSet
Classe EnumSet implementata nel file quadro delle collezioni è una delle implementazioni specializzate dell'interfaccia Set da utilizzare con tipo di enumerazione . È un'implementazione di set ad alte prestazioni, molto più veloce di HashSet. Tutti gli elementi in un set di enumerazione devono provenire da un singolo tipo di enumerazione specificato quando il set viene creato in modo esplicito o implicito. Vediamo come creare un oggetto set utilizzando questa classe.
Esempio
Giava
setinterval javascript
// 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);> >}> }> |
>
>Produzione
Set 1: [CODE, LEARN, CONTRIBUTE, QUIZ]>
Classe 3: LinkedHashSet
Classe LinkedHashSet implementata nel file quadro delle collezioni è una versione ordinata di HashSet che mantiene un elenco doppiamente collegato tra tutti gli elementi. Quando è necessario mantenere l'ordine di iterazione, viene utilizzata questa classe. Quando si scorre un HashSet l'ordine è imprevedibile, mentre un LinkedHashSet ci consente di scorrere gli elementi nell'ordine in cui sono stati inseriti. Vediamo come creare un oggetto set utilizzando questa classe.
Esempio
Giava
// 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());> >}> }> |
>
>Produzione
[India, Australia, South Africa] Set after removing Australia:[India, South Africa] Iterating over set: India South Africa>
Classe 4: Set di alberi
Classe TreeSet implementata nel file quadro delle collezioni e l'implementazione dell'interfaccia SortedSet e SortedSet estende l'interfaccia Set. Si comporta come un semplice insieme con l'eccezione che memorizza gli elementi in un formato ordinato. TreeSet utilizza una struttura dati ad albero per l'archiviazione. Gli oggetti vengono archiviati in ordine crescente. Ma possiamo eseguire l'iterazione in ordine decrescente utilizzando il metodo TreeSet.descendingIterator(). Vediamo come creare un oggetto set utilizzando questa classe.
Esempio
Giava
// 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());> >}> }> |
>
>Produzione
[Australia, India, South Africa] Set after removing Australia:[India, South Africa] Iterating over set: India South Africa>