La classe Java TreeSet implementa l'interfaccia Set che utilizza un albero per l'archiviazione. Eredita la classe AbstractSet e implementa l'interfaccia NavigableSet. Gli oggetti della classe TreeSet vengono archiviati in ordine crescente.
I punti importanti sulla classe Java TreeSet sono:
- La classe Java TreeSet contiene elementi univoci solo come HashSet.
- I tempi di accesso e recupero della classe Java TreeSet sono piuttosto rapidi.
- La classe Java TreeSet non consente l'elemento null.
- La classe Java TreeSet non è sincronizzata.
- La classe Java TreeSet mantiene l'ordine crescente.
- La classe Java TreeSet contiene elementi univoci solo come HashSet.
- I tempi di accesso e recupero della classe Java TreeSet sono piuttosto rapidi.
- La classe Java TreeSet non consente elementi null.
- La classe Java TreeSet non è sincronizzata.
- La classe Java TreeSet mantiene l'ordine crescente.
- TreeSet può consentire solo i tipi generici comparabili. Ad esempio, l'interfaccia Comparable viene implementata dalla classe StringBuffer.
Funzionamento interno della classe TreeSet
TreeSet viene implementato utilizzando un albero di ricerca binario, che si autobilancia proprio come un albero rosso-nero. Pertanto, operazioni come la ricerca, la rimozione e l'aggiunta consumano tempo O(log(N)). La ragione di ciò è nell’albero dell’autobilanciamento. Serve a garantire che l'altezza dell'albero non superi mai O(log(N)) per tutte le operazioni menzionate. Pertanto, è una delle strutture dati efficienti per mantenere ordinati i dati di grandi dimensioni e anche per eseguire operazioni su di essi.
Sincronizzazione della classe TreeSet
Come già accennato in precedenza, la classe TreeSet non è sincronizzata. Ciò significa che se più di un thread accede contemporaneamente a un set di alberi e uno dei thread che accedono lo modifica, la sincronizzazione deve essere eseguita manualmente. Di solito viene eseguito eseguendo una sincronizzazione degli oggetti che incapsula il set. Tuttavia, nel caso in cui non venga trovato alcun oggetto di questo tipo, il set deve essere racchiuso con l'aiuto del metodo Collections.synchronizedSet(). Si consiglia di utilizzare il metodo durante la fase di creazione per evitare l'accesso non sincronizzato al set. Il seguente frammento di codice mostra lo stesso.
TreeSet treeSet = new TreeSet(); Set syncrSet = Collections.synchronziedSet(treeSet);
Gerarchia della classe TreeSet
Come mostrato nel diagramma precedente, la classe Java TreeSet implementa l'interfaccia NavigableSet. L'interfaccia NavigableSet estende le interfacce SortedSet, Set, Collection e Iterable in ordine gerarchico.
programmazione di struct array c
Dichiarazione della classe TreeSet
Vediamo la dichiarazione per la classe java.util.TreeSet.
public class TreeSet extends AbstractSet implements NavigableSet, Cloneable, Serializable
Costruttori della classe Java TreeSet
| Costruttore | Descrizione |
|---|---|
| Set di alberi() | Viene utilizzato per costruire un insieme di alberi vuoto che verrà ordinato in ordine crescente secondo l'ordine naturale dell'insieme di alberi. |
| TreeSet(Raccolta c) | Viene utilizzato per costruire un nuovo insieme di alberi che contenga gli elementi della raccolta c. |
| TreeSet (comparatore comparatore) | Viene utilizzato per costruire un insieme di alberi vuoto che verrà ordinato in base al comparatore specificato. |
| Set di alberi(Set ordinati) | Viene utilizzato per creare un TreeSet che contiene gli elementi del SortedSet specificato. |
Metodi della classe Java TreeSet
| Metodo | Descrizione |
|---|---|
| somma booleana(E e) | Viene utilizzato per aggiungere l'elemento specificato a questo insieme se non è già presente. |
| booleano addAll(Collezione c) | Viene utilizzato per aggiungere a questo insieme tutti gli elementi della raccolta specificata. |
| E soffitto(E e) | Restituisce l'elemento maggiore uguale o più vicino all'elemento specificato dall'insieme, oppure null se tale elemento non esiste. |
| Comparatore comparatore() | Restituisce un comparatore che dispone gli elementi in ordine. |
| Iteratore discendenteIterator() | Viene utilizzato per ripetere gli elementi in ordine decrescente. |
| NavigableSet discendenteSet() | Restituisce gli elementi in ordine inverso. |
| E pavimento(E e) | Restituisce l'elemento uguale o più vicino all'elemento minimo specificato dall'insieme, oppure null se tale elemento non esiste. |
| SortedSet headSet(E toElement) | Restituisce il gruppo di elementi inferiori all'elemento specificato. |
| NavigableSet headSet(E toElement, booleano compreso) | Restituisce il gruppo di elementi minori o uguali (se inclusivo è vero) all'elemento specificato. |
| E higher(E e) | Restituisce l'elemento più grande più vicino all'elemento specificato dall'insieme, oppure null se tale elemento non esiste. |
| Iteratore iteratore() | Viene utilizzato per scorrere gli elementi in ordine crescente. |
| E lower(E e) | Restituisce l'elemento minimo più vicino all'elemento specificato dall'insieme, oppure null se tale elemento non esiste. |
| E pollFirst() | Viene utilizzato per recuperare e rimuovere l'elemento più basso (il primo). |
| E sondaggioUltimo() | Viene utilizzato per recuperare e rimuovere l'elemento più alto (ultimo). |
| divisore divisore() | Viene utilizzato per creare uno spliterator con associazione tardiva e fail-fast sugli elementi. |
| NavigableSet subSet(E fromElement, booleano fromInclusive, E toElement, booleano toInclusive) | Restituisce un insieme di elementi che si trovano nell'intervallo specificato. |
| Sottoinsieme dell'insieme ordinato(E daElemento, E aElemento)) | Restituisce un insieme di elementi compresi nell'intervallo specificato che include fromElement ed esclude toElement. |
| SortedSet tailSet(E fromElement) | Restituisce un insieme di elementi maggiori o uguali all'elemento specificato. |
| NavigableSet tailSet(E fromElement, booleano incluso) | Restituisce un insieme di elementi maggiori o uguali (se inclusivo è vero) all'elemento specificato. |
| booleano contiene(Oggetto o) | Restituisce vero se questo insieme contiene l'elemento specificato. |
| booleano è vuoto() | Restituisce vero se questo insieme non contiene elementi. |
| booleano rimuovi(Oggetto o) | Viene utilizzato per rimuovere l'elemento specificato da questo insieme, se presente. |
| vuoto chiaro() | Viene utilizzato per rimuovere tutti gli elementi da questo set. |
| Clone oggetto() | Restituisce una copia superficiale di questa istanza TreeSet. |
| E prima() | Restituisce il primo elemento (il più basso) attualmente in questo insieme ordinato. |
| E ultimo() | Restituisce l'ultimo (il più alto) elemento attualmente in questo insieme ordinato. |
| dimensione intera() | Restituisce il numero di elementi in questo insieme. |
Esempi di set di alberi Java
Esempio 1 di Java TreeSet:
Vediamo un semplice esempio di Java TreeSet.
Nome del file: TreeSet1.java
import java.util.*; class TreeSet1{ public static void main(String args[]){ //Creating and adding elements TreeSet al=new TreeSet(); al.add('Ravi'); al.add('Vijay'); al.add('Ravi'); al.add('Ajay'); //Traversing elements Iterator itr=al.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } Provalo adesso Produzione:
Ajay Ravi Vijay
Esempio 2 di Java TreeSet:
Vediamo un esempio di attraversamento degli elementi in ordine decrescente.
algoritmo di 'prim''
Nome del file: TreeSet2.java
import java.util.*; class TreeSet2{ public static void main(String args[]){ TreeSet set=new TreeSet(); set.add('Ravi'); set.add('Vijay'); set.add('Ajay'); System.out.println('Traversing element through Iterator in descending order'); Iterator i=set.descendingIterator(); while(i.hasNext()) { System.out.println(i.next()); } } } Provalo adesso Produzione:
Traversing element through Iterator in descending order Vijay Ravi Ajay Traversing element through NavigableSet in descending order Vijay Ravi Ajay
Esempio 3 di Java TreeSet:
Vediamo un esempio per recuperare e rimuovere il valore più alto e quello più basso.
Nome del file: TreeSet3.java
l'attrice zeenat aman
import java.util.*; class TreeSet3{ public static void main(String args[]){ TreeSet set=new TreeSet(); set.add(24); set.add(66); set.add(12); set.add(15); System.out.println('Lowest Value: '+set.pollFirst()); System.out.println('Highest Value: '+set.pollLast()); } } Produzione:
Lowest Value: 12 Highest Value: 66
Esempio 4 di Java TreeSet:
In questo esempio, eseguiamo varie operazioni NavigableSet.
Nome del file: TreeSet4.java
pulire la cache npm
import java.util.*; class TreeSet4{ public static void main(String args[]){ TreeSet set=new TreeSet(); set.add('A'); set.add('B'); set.add('C'); set.add('D'); set.add('E'); System.out.println('Initial Set: '+set); System.out.println('Reverse Set: '+set.descendingSet()); System.out.println('Head Set: '+set.headSet('C', true)); System.out.println('SubSet: '+set.subSet('A', false, 'E', true)); System.out.println('TailSet: '+set.tailSet('C', false)); } } Produzione:
Initial Set: [A, B, C, D, E] Reverse Set: [E, D, C, B, A] Head Set: [A, B, C] SubSet: [B, C, D, E] TailSet: [D, E]
Esempio 5 di Java TreeSet:
In questo esempio, eseguiamo varie operazioni SortedSetSet.
Nome del file: TreeSet5.java
import java.util.*; class TreeSet5{ public static void main(String args[]){ TreeSet set=new TreeSet(); set.add('A'); set.add('B'); set.add('C'); set.add('D'); set.add('E'); System.out.println('Intial Set: '+set); System.out.println('Head Set: '+set.headSet('C')); System.out.println('SubSet: '+set.subSet('A', 'E')); System.out.println('TailSet: '+set.tailSet('C')); } } Produzione:
Shreya Ghoshal, primo marito
Intial Set: [A, B, C, D, E] Head Set: [A, B] SubSet: [A, B, C, D] TailSet: [C, D, E]
Esempio di Java TreeSet: libro
Vediamo un esempio di TreeSet in cui aggiungiamo libri al set e stampiamo tutti i libri. Gli elementi in TreeSet devono essere di tipo Comparable. Le classi String e Wrapper sono comparabili per impostazione predefinita. Per aggiungere oggetti definiti dall'utente in TreeSet, è necessario implementare l'interfaccia Comparable.
Nome del file: TreeSetExample.java
import java.util.*; class Book implements Comparable{ int id; String name,author,publisher; int quantity; public Book(int id, String name, String author, String publisher, int quantity) { this.id = id; this.name = name; this.author = author; this.publisher = publisher; this.quantity = quantity; } // implementing the abstract method public int compareTo(Book b) { if(id>b.id){ return 1; }else if(id <b.id){ return -1; }else{ 0; } public class treesetexample { static void main(string[] args) set treeset(); creating books book b1="new" book(121,'let us c','yashwant kanetkar','bpb',8); b2="new" book(233,'operating system','galvin','wiley',6); b3="new" book(101,'data communications & networking','forouzan','mc graw hill',4); adding to treeset set.add(b1); set.add(b2); set.add(b3); traversing for(book b:set){ system.out.println(b.id+' '+b.name+' '+b.author+' '+b.publisher+' '+b.quantity); < pre> <p> <strong>Output:</strong> </p> <pre>101 Data Communications & Networking Forouzan Mc Graw Hill 4 121 Let us C Yashwant Kanetkar BPB 8 233 Operating System Galvin Wiley 6 </pre> <h3>ClassCast Exception in TreeSet</h3> <p>If we add an object of the class that is not implementing the Comparable interface, the ClassCast Exception is raised. Observe the following program.</p> <p> <strong>FileName:</strong> ClassCastExceptionTreeSet.java</p> <pre> // important import statement import java.util.*; class Employee { int empId; String name; // getting the name of the employee String getName() { return this.name; } // setting the name of the employee void setName(String name) { this.name = name; } // setting the employee id // of the employee void setId(int a) { this.empId = a; } // retrieving the employee id of // the employee int getId() { return this.empId; } } public class ClassCastExceptionTreeSet { // main method public static void main(String[] argvs) { // creating objects of the class Employee Employee obj1 = new Employee(); Employee obj2 = new Employee(); TreeSet ts = new TreeSet(); // adding the employee objects to // the TreeSet class ts.add(obj1); ts.add(obj2); System.out.println('The program has been executed successfully.'); } } </pre> <p>When we compile the above program, we get the ClassCastException, as shown below.</p> <pre> Exception in thread 'main' java.lang.ClassCastException: class Employee cannot be cast to class java.lang.Comparable (Employee is in unnamed module of loader 'app'; java.lang.Comparable is in module java.base of loader 'bootstrap') at java.base/java.util.TreeMap.compare(TreeMap.java:1569) at java.base/java.util.TreeMap.addEntryToEmptyMap(TreeMap.java:776) at java.base/java.util.TreeMap.put(TreeMap.java:785) at java.base/java.util.TreeMap.put(TreeMap.java:534) at java.base/java.util.TreeSet.add(TreeSet.java:255) at ClassCastExceptionTreeSet.main(ClassCastExceptionTreeSet.java:52) </pre> <p> <strong>Explanation:</strong> In the above program, it is required to implement a Comparable interface. It is because the TreeSet maintains the sorting order, and for doing the sorting the comparison of different objects that are being inserted in the TreeSet is must, which is accomplished by implementing the Comparable interface.</p> <hr></b.id){> Eccezione ClassCast in TreeSet
Se aggiungiamo un oggetto della classe che non implementa l'interfaccia Comparable, viene sollevata l'eccezione ClassCast. Osservare il seguente programma.
Nome del file: ClassCastExceptionTreeSet.java
// important import statement import java.util.*; class Employee { int empId; String name; // getting the name of the employee String getName() { return this.name; } // setting the name of the employee void setName(String name) { this.name = name; } // setting the employee id // of the employee void setId(int a) { this.empId = a; } // retrieving the employee id of // the employee int getId() { return this.empId; } } public class ClassCastExceptionTreeSet { // main method public static void main(String[] argvs) { // creating objects of the class Employee Employee obj1 = new Employee(); Employee obj2 = new Employee(); TreeSet ts = new TreeSet(); // adding the employee objects to // the TreeSet class ts.add(obj1); ts.add(obj2); System.out.println('The program has been executed successfully.'); } } Quando compiliamo il programma sopra, otteniamo ClassCastException, come mostrato di seguito.
Exception in thread 'main' java.lang.ClassCastException: class Employee cannot be cast to class java.lang.Comparable (Employee is in unnamed module of loader 'app'; java.lang.Comparable is in module java.base of loader 'bootstrap') at java.base/java.util.TreeMap.compare(TreeMap.java:1569) at java.base/java.util.TreeMap.addEntryToEmptyMap(TreeMap.java:776) at java.base/java.util.TreeMap.put(TreeMap.java:785) at java.base/java.util.TreeMap.put(TreeMap.java:534) at java.base/java.util.TreeSet.add(TreeSet.java:255) at ClassCastExceptionTreeSet.main(ClassCastExceptionTreeSet.java:52)
Spiegazione: Nel programma precedente è necessario implementare un'interfaccia comparabile. È perché TreeSet mantiene l'ordinamento e per eseguire l'ordinamento è necessario il confronto di diversi oggetti che vengono inseriti in TreeSet, cosa che si ottiene implementando l'interfaccia Comparable.