A classe Java TreeSet implementa a interface Set que usa uma árvore para armazenamento. Ele herda a classe AbstractSet e implementa a interface NavigableSet. Os objetos da classe TreeSet são armazenados em ordem crescente.
Os pontos importantes sobre a classe Java TreeSet são:
- A classe Java TreeSet contém elementos exclusivos apenas como HashSet.
- Os tempos de acesso e recuperação da classe Java TreeSet são silenciosos e rápidos.
- A classe Java TreeSet não permite elemento nulo.
- A classe Java TreeSet não está sincronizada.
- A classe Java TreeSet mantém a ordem crescente.
- A classe Java TreeSet contém elementos exclusivos apenas como HashSet.
- Os tempos de acesso e recuperação da classe Java TreeSet são bastante rápidos.
- A classe Java TreeSet não permite elementos nulos.
- A classe Java TreeSet não é sincronizada.
- A classe Java TreeSet mantém a ordem crescente.
- O TreeSet só pode permitir tipos genéricos comparáveis. Por exemplo, a interface Comparable está sendo implementada pela classe StringBuffer.
Funcionamento interno da classe TreeSet
TreeSet está sendo implementado usando uma árvore de pesquisa binária, que se autoequilibra como uma árvore vermelha-preta. Portanto, operações como pesquisar, remover e adicionar consomem tempo O(log(N)). A razão por trás disso está na árvore do autoequilíbrio. Ele existe para garantir que a altura da árvore nunca exceda O(log(N)) para todas as operações mencionadas. Portanto, é uma das estruturas de dados eficientes para manter os grandes dados que são classificados e também para realizar operações sobre eles.
Sincronização da classe TreeSet
Como já mencionado acima, a classe TreeSet não está sincronizada. Isso significa que se mais de um thread acessar simultaneamente um conjunto de árvores e um dos threads de acesso o modificar, a sincronização deverá ser feita manualmente. Geralmente isso é feito fazendo alguma sincronização de objeto que encapsula o conjunto. No entanto, no caso em que tal objeto não seja encontrado, o conjunto deve ser agrupado com a ajuda do método Collections.synchronizedSet(). Aconselha-se utilizar o método no momento da criação para evitar o acesso não sincronizado do conjunto. O trecho de código a seguir mostra o mesmo.
TreeSet treeSet = new TreeSet(); Set syncrSet = Collections.synchronziedSet(treeSet);
Hierarquia da classe TreeSet
Conforme mostrado no diagrama acima, a classe Java Treeset implementa a interface Navigableset. A interface Navigableset estende o STOREDSET, SET, Coleção e interfaces iteráveis em ordem hierárquica.
campo jtext
Declaração da classe Treeset
Vamos ver a Declaração para Java.util.TreeSet Class.
java olá mundo
public class TreeSet extends AbstractSet implements NavigableSet, Cloneable, Serializable
Construtores da classe Java TreeSet
| Construtor | Descrição |
|---|---|
| ConjuntoÁrvore() | É usado para construir um conjunto de árvores vazio que será classificado em ordem crescente de acordo com a ordem natural do conjunto de árvores. |
| TreeSet (Coleção c) | É usado para construir um novo conjunto de árvores que contém os elementos da coleção c. |
| TreeSet (comparador do comparador) | É usado para construir um conjunto de árvore vazio que será classificado de acordo com um determinado comparador. |
| TreeSet(SortedSets) | É usado para construir uma árvore que contém os elementos do conjunto de classificação fornecido. |
Métodos da classe Java Treeset
| Método | Descrição |
|---|---|
| adição booleana (E e) | É usado para adicionar o elemento especificado a este conjunto, se ainda não estiver presente. |
| booleano addAll (Coleção c) | É usado para adicionar todos os elementos na coleção especificada a este conjunto. |
| E teto (e e) | Ele retorna o elemento maior ou mais próximo do elemento especificado do conjunto, ou NULL, não existe esse elemento. |
| Comparador comparador() | Ele retorna um comparador que organiza os elementos em ordem. |
| Iterador descendenteIterator() | É usado para iterar os elementos em ordem decrescente. |
| NavigableSet descendenteSet() | Ele retorna os elementos em ordem inversa. |
| Piso E(E e) | Ele retorna o elemento igual ou mais próximo do elemento especificado do conjunto, ou nulo não existe esse elemento. |
| Fone de ouvido STOREDEDSET (EFOELEMENT) | Ele retorna o grupo de elementos menores que o elemento especificado. |
| Fone de ouvido Navigableset (E -Toelement, Boolean Inclusive) | Ele retorna o grupo de elementos que são menores ou iguais a (se, inclusive for verdadeiro) o elemento especificado. |
| E superior(E e) | Ele retorna o maior elemento mais próximo do elemento especificado do conjunto, ou nulo, tal elemento não existe. |
| Iterador iterador() | É usado para iterar os elementos em ordem ascendente. |
| E inferior(E e) | Ele retorna o elemento menos próximo do elemento especificado do conjunto, ou NULL, não existe esse elemento. |
| E enquetePrimeiro() | É usado para recuperar e remover o elemento mais baixo (primeiro). |
| E enqueteÚltima() | É usado para recuperar e remover o elemento mais alto (último). |
| Spliterator Spliterator () | Ele é usado para criar um divisor de ligação tardia e de falha rápida sobre os elementos. |
| NavigableSet subSet (E fromElement, booleano fromInclusive, E toElement, boolean toInclusive) | Ele retorna um conjunto de elementos que estão entre o intervalo fornecido. |
| SortedSet subSet(E fromElement, E toElement)) | Ele retorna um conjunto de elementos que estão entre um determinado intervalo que inclui fromElement e exclui toElement. |
| SortedSet Tailset (E FromElement) | Ele retorna um conjunto de elementos maiores ou iguais ao elemento especificado. |
| NavigableSet tailSet(E fromElement, booleano inclusive) | Ele retorna um conjunto de elementos que são maiores ou iguais (se, inclusive for verdadeiro) ao elemento especificado. |
| booleano contém (Objeto o) | Retorna verdadeiro se este conjunto contiver o elemento especificado. |
| booleano isEmpty() | Retorna verdadeiro se este conjunto não contiver elementos. |
| remoção booleana (Objeto o) | É usado para remover o elemento especificado deste conjunto, se estiver presente. |
| vazio claro() | É usado para remover todos os elementos deste conjunto. |
| Clone de objeto() | Ele retorna uma cópia superficial desta instância TreeSet. |
| E primeiro() | Ele retorna o primeiro elemento (mais baixo) atualmente neste conjunto classificado. |
| E último() | Ele retorna o último elemento (mais alto) atualmente neste conjunto classificado. |
| tamanho interno() | Ele retorna o número de elementos neste conjunto. |
Exemplos de TreeSet Java
Java TreeSet Exemplo 1:
Vamos ver um exemplo simples de Java Treeset.
Nome do arquivo: 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()); } } } Teste agora Saída:
Ajay Ravi Vijay
Java TreeSet Exemplo 2:
Vejamos um exemplo de deslocamento de elementos em ordem decrescente.
Nome do arquivo: TRESET2.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()); } } } Teste agora Saída:
Traversing element through Iterator in descending order Vijay Ravi Ajay Traversing element through NavigableSet in descending order Vijay Ravi Ajay
Java TreeSet Exemplo 3:
Vamos ver um exemplo para recuperar e remover o valor mais alto e o mais baixo.
Nome do arquivo: TreeSet3.java
programação em matrizes c
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()); } } Saída:
Lowest Value: 12 Highest Value: 66
Java TreeSet Exemplo 4:
Neste exemplo, realizamos várias operações NavigableSet.
Nome do arquivo: Treeset4.Java
tentando int
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)); } } Saída:
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 Exemplo 5:
Neste exemplo, realizamos várias operações SortedSetSet.
Nome do arquivo: 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')); } } Saída:
Intial Set: [A, B, C, D, E] Head Set: [A, B] SubSet: [A, B, C, D] TailSet: [C, D, E]
Exemplo de Java Treeset: livro
Vamos ver um exemplo de TreeSet onde adicionamos livros ao conjunto e imprimimos todos os livros. Os elementos em TreeSet devem ser do tipo Comparable. As classes String e Wrapper são comparáveis por padrão. Para adicionar objetos definidos pelo usuário em TreeSet, você precisa implementar a interface Comparable.
Nome do arquivo: 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){> Exceção ClassCast em TreeSet
Se adicionarmos um objeto da classe que não está implementando a interface Comparable, a exceção ClassCast será gerada. Observe o seguinte programa.
como transformar uma string em um int
Nome do arquivo: 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 compilamos o programa acima, obtemos ClassCastException, conforme mostrado abaixo.
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)
Explicação: No programa acima, é necessário implementar uma interface comparável. Isso ocorre porque o TreeSet mantém a ordem de classificação, e para fazer a classificação é necessária a comparação dos diferentes objetos que estão sendo inseridos no TreeSet, o que é feito através da implementação da interface Comparable.