La clase Java TreeSet implementa la interfaz Set que utiliza un árbol para el almacenamiento. Hereda la clase AbstractSet e implementa la interfaz NavigableSet. Los objetos de la clase TreeSet se almacenan en orden ascendente.
Los puntos importantes sobre la clase Java TreeSet son:
- La clase Java TreeSet contiene elementos únicos solo como HashSet.
- Los tiempos de acceso y recuperación de clases de Java TreeSet son bastante rápidos.
- La clase Java TreeSet no permite elementos nulos.
- La clase Java TreeSet no está sincronizada.
- La clase Java TreeSet mantiene el orden ascendente.
- La clase Java TreeSet contiene elementos únicos solo como HashSet.
- Los tiempos de acceso y recuperación de clases de Java TreeSet son bastante rápidos.
- La clase Java Treeset no permite elementos nulos.
- La clase Java TreeSet no está sincronizada.
- La clase Java TreeSet mantiene el orden ascendente.
- El TreeSet sólo puede permitir aquellos tipos genéricos que sean comparables. Por ejemplo, la clase StringBuffer está implementando la interfaz Comparable.
Funcionamiento interno de la clase TreeSet
TreeSet se implementa utilizando un árbol de búsqueda binario, que se autoequilibra como un árbol rojo-negro. Por lo tanto, operaciones como buscar, eliminar y agregar consumen tiempo O(log(N)). La razón detrás de esto está en el árbol de autoequilibrio. Está ahí para garantizar que la altura del árbol nunca exceda O(log(N)) para todas las operaciones mencionadas. Por lo tanto, es una de las estructuras de datos eficientes para mantener la gran cantidad de datos ordenados y también para realizar operaciones con ellos.
Sincronización de la clase TreeSet
Como ya se mencionó anteriormente, la clase TreeSet no está sincronizada. Significa que si más de un subproceso accede simultáneamente a un conjunto de árboles y uno de los subprocesos que acceden lo modifica, entonces la sincronización debe realizarse manualmente. Por lo general, se realiza mediante alguna sincronización de objetos que encapsula el conjunto. Sin embargo, en el caso de que no se encuentre dicho objeto, el conjunto debe empaquetarse con la ayuda del método Collections.synchronizedSet(). Se recomienda utilizar el método durante el tiempo de creación para evitar el acceso no sincronizado del conjunto. El siguiente fragmento de código muestra lo mismo.
TreeSet treeSet = new TreeSet(); Set syncrSet = Collections.synchronziedSet(treeSet);
Jerarquía de la clase TreeSet
Como se muestra en el diagrama anterior, la clase Java TreeSet implementa la interfaz NavigableSet. La interfaz NavigableSet amplía las interfaces SortedSet, Set, Collection e Iterable en orden jerárquico.
cambiar el nombre en el directorio de Linux
Declaración de clase TreeSet
Veamos la declaración de la clase java.util.TreeSet.
ejemplos de sistemas operativos
public class TreeSet extends AbstractSet implements NavigableSet, Cloneable, Serializable
Constructores de la clase Java TreeSet
| Constructor | Descripción |
|---|---|
| Conjunto de árboles() | Se utiliza para construir un conjunto de árboles vacío que se ordenará en orden ascendente según el orden natural del conjunto de árboles. |
| TreeSet(Colección c) | Se utiliza para construir un nuevo conjunto de árboles que contiene los elementos de la colección c. |
| TreeSet (comparador comparador) | Se utiliza para construir un conjunto de árboles vacío que se ordenará según el comparador dado. |
| TreeSet (sortedset s) | Se utiliza para construir un TreeSet que contiene los elementos del SortedSet dado. |
Métodos de la clase Java TreeSet
| Método | Descripción |
|---|---|
| suma booleana (E e) | Se utiliza para agregar el elemento especificado a este conjunto si aún no está presente. |
| booleano addAll (Colección c) | Se utiliza para agregar todos los elementos de la colección especificada a este conjunto. |
| techo E(E e) | Devuelve el elemento mayor igual o más cercano al elemento especificado del conjunto, o nulo si no existe tal elemento. |
| Comparador comparador() | Devuelve un comparador que organiza los elementos en orden. |
| Iterador descendenteIterador() | Se utiliza para iterar los elementos en orden descendente. |
| NavigableSet conjunto descendente() | Devuelve los elementos en orden inverso. |
| E piso(E e) | Devuelve el elemento mínimo igual o más cercano del elemento especificado del conjunto, o nulo si no existe tal elemento. |
| Conjunto ordenado conjunto de cabezas (E a elemento) | Devuelve el grupo de elementos que son menores que el elemento especificado. |
| NavigableSet headSet(E toElement, booleano inclusive) | Devuelve el grupo de elementos que son menores o iguales (si inclusive es verdadero) el elemento especificado. |
| E más alto (E E) | Devuelve el elemento más grande más cercano al elemento especificado del conjunto, o nulo si no existe tal elemento. |
| iterador iterador() | Se utiliza para iterar los elementos en orden ascendente. |
| E más bajo (e e) | Devuelve el elemento mínimo más cercano al elemento especificado del conjunto, o nulo si no existe tal elemento. |
| Encuesta EPrimera() | Se usa para recuperar y eliminar el elemento más bajo (primero). |
| E encuestaLast() | Se usa para recuperar y eliminar el elemento más alto (último). |
| divisor divisor() | Se usa para crear un spliterator de unión tardía y falla sobre los elementos. |
| Subconjunto de navegables (E desde elemento, booleano de incluido, e toelement, boolean toinclusive) | Devuelve un conjunto de elementos que se encuentran entre el rango dado. |
| Subconjunto de conjunto ordenado (E de elemento, E a elemento)) | Devuelve un conjunto de elementos que se encuentran entre el rango dado que incluye a partir delilado y excluye el toelemento. |
| Conjunto ordenado conjunto de cola (E de elemento) | Devuelve un conjunto de elementos que son mayores o iguales al elemento especificado. |
| Navegable de cola (e desde element, boolean inclusive) | Devuelve un conjunto de elementos que son mayores o iguales a (si, inclusive es verdadero) el elemento especificado. |
| booleano contiene (Objeto o) | Devuelve verdadero si este conjunto contiene el elemento especificado. |
| booleano está vacío() | Devuelve verdadero si este conjunto no contiene elementos. |
| booleano eliminar (Objeto o) | Se usa para eliminar el elemento especificado de este conjunto si está presente. |
| vacío claro() | Se utiliza para eliminar todos los elementos de este conjunto. |
| Clon de objeto() | Devuelve una copia superficial de esta instancia de Treeset. |
| mi primero() | Devuelve el primer elemento (más bajo) actualmente en este conjunto ordenado. |
| mi último() | Devuelve el último elemento (más alto) actualmente en este conjunto ordenado. |
| tamaño entero() | Devuelve el número de elementos de este conjunto. |
Ejemplos de conjuntos de árboles de Java
Java Treeset Ejemplo 1:
Veamos un ejemplo sencillo de Java TreeSet.
Nombre del archivo: 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()); } } } Pruébalo ahora Producción:
Ajay Ravi Vijay
Ejemplo 2 de conjunto de árboles de Java:
Veamos un ejemplo de transversión de elementos en orden descendente.
Nombre del archivo: 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()); } } } Pruébalo ahora Producción:
Traversing element through Iterator in descending order Vijay Ravi Ajay Traversing element through NavigableSet in descending order Vijay Ravi Ajay
Ejemplo 3 de conjunto de árboles de Java:
Veamos un ejemplo para recuperar y eliminar el valor más alto y más bajo.
Nombre del archivo: TreeSet3.java
ordenar al azar en sql
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()); } } Producción:
Lowest Value: 12 Highest Value: 66
Ejemplo 4 de conjunto de árboles de Java:
En este ejemplo, realizamos varias operaciones NavigableSet.
Nombre del archivo: TreeSet4.java
ordenar una lista de matrices en java
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)); } } Producción:
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 Ejemplo 5:
En este ejemplo, realizamos varias operaciones SortedSetSet.
Nombre del archivo: 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')); } } Producción:
Intial Set: [A, B, C, D, E] Head Set: [A, B] SubSet: [A, B, C, D] TailSet: [C, D, E]
Ejemplo de Java TreeSet: libro
Veamos un ejemplo de TreeSet donde estamos agregando libros al set e imprimiendo todos los libros. Los elementos de TreeSet deben ser de tipo Comparable. Las clases String y Wrapper son comparables de forma predeterminada. Para agregar objetos definidos por el usuario en TreeSet, debe implementar la interfaz Comparable.
Nombre del archivo: 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){> Excepción de ClassCast en TreeSet
Si agregamos un objeto de la clase que no implementa la interfaz Comparable, se genera la excepción ClassCast. Observe el siguiente programa.
objeto a json en java
Nombre del archivo: 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.'); } } Cuando compilamos el programa anterior, obtenemos ClassCastException, como se muestra a continuación.
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)
Explicación: En el programa anterior, se requiere implementar una interfaz Comparable. Esto se debe a que TreeSet mantiene el orden de clasificación y, para realizar la clasificación, es imprescindible comparar los diferentes objetos que se insertan en el TreeSet, lo que se logra implementando la interfaz Comparable.