Die Java TreeSet-Klasse implementiert die Set-Schnittstelle, die einen Baum zur Speicherung verwendet. Es erbt die AbstractSet-Klasse und implementiert die NavigableSet-Schnittstelle. Die Objekte der TreeSet-Klasse werden in aufsteigender Reihenfolge gespeichert.

Die wichtigen Punkte zur Java TreeSet-Klasse sind:

• Die Java TreeSet-Klasse enthält nur eindeutige Elemente wie HashSet.
• Die Zugriffs- und Abrufzeiten der Java TreeSet-Klasse sind recht schnell.
• Die Java TreeSet-Klasse lässt kein Nullelement zu.
• Die Java TreeSet-Klasse ist nicht synchronisiert.
• Die Java TreeSet-Klasse behält die aufsteigende Reihenfolge bei.

• Die Java TreeSet-Klasse enthält nur eindeutige Elemente wie HashSet.
• Die Zugriffs- und Abrufzeiten der Java TreeSet-Klasse sind recht schnell.
• Die Java TreeSet-Klasse lässt keine Nullelemente zu.
• Die Java TreeSet-Klasse ist nicht synchronisiert.
• Die Java TreeSet-Klasse behält die aufsteigende Reihenfolge bei.
• Das TreeSet kann nur solche generischen Typen zulassen, die vergleichbar sind. Beispielsweise wird die Comparable-Schnittstelle von der StringBuffer-Klasse implementiert.

Interne Funktionsweise der TreeSet-Klasse

TreeSet wird mithilfe eines binären Suchbaums implementiert, der sich wie ein Rot-Schwarz-Baum selbst ausgleicht. Daher beanspruchen Vorgänge wie Suchen, Entfernen und Hinzufügen O(log(N)) Zeit. Der Grund dafür liegt im selbstausgleichenden Baum. Es soll sicherstellen, dass die Baumhöhe bei allen genannten Operationen niemals O(log(N)) überschreitet. Daher handelt es sich um eine der effizientesten Datenstrukturen, um große Datenmengen sortiert aufzubewahren und auch Operationen daran durchzuführen.

Synchronisierung der TreeSet-Klasse

Wie bereits oben erwähnt, ist die TreeSet-Klasse nicht synchronisiert. Das heißt, wenn mehr als ein Thread gleichzeitig auf einen Baumsatz zugreift und einer der zugreifenden Threads ihn ändert, muss die Synchronisierung manuell durchgeführt werden. Dies erfolgt normalerweise durch eine Objektsynchronisierung, die den Satz kapselt. Falls jedoch kein solches Objekt gefunden wird, muss der Satz mithilfe der Methode Collections.synchronizedSet() verpackt werden. Es wird empfohlen, die Methode während der Erstellungszeit zu verwenden, um einen unsynchronisierten Zugriff auf den Satz zu vermeiden. Der folgende Codeausschnitt zeigt dasselbe.

 TreeSet treeSet = new TreeSet(); Set syncrSet = Collections.synchronziedSet(treeSet); 

Hierarchie der TreeSet-Klasse

Wie im obigen Diagramm gezeigt, implementiert die Java TreeSet-Klasse die NavigableSet-Schnittstelle. Die NavigableSet-Schnittstelle erweitert die Schnittstellen SortedSet, Set, Collection und Iterable in hierarchischer Reihenfolge.

Pothineni-Widder

TreeSet-Klassendeklaration

Sehen wir uns die Deklaration für die Klasse java.util.TreeSet an.

 public class TreeSet extends AbstractSet implements NavigableSet, Cloneable, Serializable 

Konstruktoren der Java TreeSet-Klasse

Methoden der Java TreeSet-Klasse

Java TreeSet-Beispiele

Java TreeSet-Beispiel 1:

Sehen wir uns ein einfaches Beispiel für Java TreeSet an.

String in Datum konvertieren

Dateiname: 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()); } } } 

Ausgabe:

Ajay Ravi Vijay 

Java TreeSet-Beispiel 2:

Sehen wir uns ein Beispiel für das Durchlaufen von Elementen in absteigender Reihenfolge an.

Dateiname: 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()); } } } 

Ausgabe:

Traversing element through Iterator in descending order Vijay Ravi Ajay Traversing element through NavigableSet in descending order Vijay Ravi Ajay 

Java TreeSet-Beispiel 3:

Sehen wir uns ein Beispiel zum Abrufen und Entfernen des höchsten und niedrigsten Werts an.

Dateiname: TreeSet3.java

Git, füge alles hinzu

 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()); } } 

Ausgabe:

 Lowest Value: 12 Highest Value: 66 

Java TreeSet-Beispiel 4:

In diesem Beispiel führen wir verschiedene NavigableSet-Operationen durch.

Dateiname: TreeSet4.java

Java-Integer in String umwandeln

 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)); } } 

Ausgabe:

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] 

Java TreeSet-Beispiel 5:

In diesem Beispiel führen wir verschiedene SortedSetSet-Operationen durch.

Dateiname: 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')); } } 

Ausgabe:

Intial Set: [A, B, C, D, E] Head Set: [A, B] SubSet: [A, B, C, D] TailSet: [C, D, E] 

Java TreeSet-Beispiel: Buch

Sehen wir uns ein TreeSet-Beispiel an, in dem wir dem Set Bücher hinzufügen und alle Bücher drucken. Die Elemente in TreeSet müssen vom Typ Comparable sein. String- und Wrapper-Klassen sind standardmäßig vergleichbar. Um benutzerdefinierte Objekte in TreeSet hinzuzufügen, müssen Sie die Comparable-Schnittstelle implementieren.

Junit-Testfälle

Dateiname: 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&gt;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 &amp; 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(&apos;The program has been executed successfully.&apos;); } } </pre> <p>When we compile the above program, we get the ClassCastException, as shown below.</p> <pre> Exception in thread &apos;main&apos; java.lang.ClassCastException: class Employee cannot be cast to class java.lang.Comparable (Employee is in unnamed module of loader &apos;app&apos;; java.lang.Comparable is in module java.base of loader &apos;bootstrap&apos;) 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){>

ClassCast-Ausnahme in TreeSet

Wenn wir ein Objekt der Klasse hinzufügen, das die Comparable-Schnittstelle nicht implementiert, wird die ClassCast-Ausnahme ausgelöst. Beachten Sie das folgende Programm.

Dateiname: 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.'); } } 

Wenn wir das obige Programm kompilieren, erhalten wir die ClassCastException, wie unten gezeigt.

 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) 

Erläuterung: Im obigen Programm ist es erforderlich, eine vergleichbare Schnittstelle zu implementieren. Dies liegt daran, dass das TreeSet die Sortierreihenfolge beibehält und für die Sortierung der Vergleich verschiedener Objekte, die in das TreeSet eingefügt werden, erforderlich ist, was durch die Implementierung der Comparable-Schnittstelle erreicht wird.