Java TreeSet
Java TreeSet
Neste tutorial, aprenderemos sobre a classe Java TreeSet e suas diversas operações e métodos com a ajuda de exemplos.
O
TreeSet A classe da estrutura de coleções Java fornece a funcionalidade de uma estrutura de dados em árvore. Ele estende a interface NavigableSet.
Criando um TreeSet
Para criar um conjunto de árvore, devemos importar o
java.util.TreeSet pacote primeiro. Depois de importar o pacote, veja como podemos criar um
TreeSet em Java.
TreeSet<Integer> numbers = new TreeSet<>();
Aqui, criamos um
TreeSet sem nenhum argumento. Neste caso, os elementos em TreeSet são classificados naturalmente (ordem crescente). No entanto, podemos personalizar a classificação dos elementos usando o
Comparator interface. Vamos aprender sobre isso mais tarde neste tutorial. Métodos de TreeSet
O
TreeSet classe fornece vários métodos que nos permitem realizar várias operações no conjunto. Inserir elementos no TreeSet
add()- insere o elemento especificado no conjuntoaddAll()- insere todos os elementos da coleção especificada no conjunto
Por exemplo,
import java.util.TreeSet;
class Main {
public static void main(String[] args) {
TreeSet<Integer> evenNumbers = new TreeSet<>();
// Using the add() method
evenNumbers.add(2);
evenNumbers.add(4);
evenNumbers.add(6);
System.out.println("TreeSet: " + evenNumbers);
TreeSet<Integer> numbers = new TreeSet<>();
numbers.add(1);
// Using the addAll() method
numbers.addAll(evenNumbers);
System.out.println("New TreeSet: " + numbers);
}
}
Saída
TreeSet: [2, 4, 6] New TreeSet: [1, 2, 4, 6]
Acessar elementos do TreeSet
Para acessar os elementos de um conjunto de árvore, podemos usar o
iterator() método. Para usar este método, devemos importar java.util.Iterator pacote. Por exemplo,
import java.util.TreeSet;
import java.util.Iterator;
class Main {
public static void main(String[] args) {
TreeSet<Integer> numbers = new TreeSet<>();
numbers.add(2);
numbers.add(5);
numbers.add(6);
System.out.println("TreeSet: " + numbers);
// Calling iterator() method
Iterator<Integer> iterate = numbers.iterator();
System.out.print("TreeSet using Iterator: ");
// Accessing elements
while(iterate.hasNext()) {
System.out.print(iterate.next());
System.out.print(", ");
}
}
}
Saída
TreeSet: [2, 5, 6] TreeSet using Iterator: 2, 5, 6,
Remover elementos
remove()- remove o elemento especificado do conjuntoremoveAll()- remove todos os elementos do conjunto
Por exemplo,
import java.util.TreeSet;
class Main {
public static void main(String[] args) {
TreeSet<Integer> numbers = new TreeSet<>();
numbers.add(2);
numbers.add(5);
numbers.add(6);
System.out.println("TreeSet: " + numbers);
// Using the remove() method
boolean value1 = numbers.remove(5);
System.out.println("Is 5 removed? " + value1);
// Using the removeAll() method
boolean value2 = numbers.removeAll(numbers);
System.out.println("Are all elements removed? " + value2);
}
}
Saída
TreeSet: [2, 5, 6] Is 5 removed? true Are all elements removed? true
Métodos de navegação
Desde o
TreeSet classe implementa NavigableSet , ele fornece vários métodos para navegar pelos elementos do conjunto de árvores. 1. Métodos first() e last()
first()- retorna o primeiro elemento do conjuntolast()- retorna o último elemento do conjunto
Por exemplo,
import java.util.TreeSet;
class Main {
public static void main(String[] args) {
TreeSet<Integer> numbers = new TreeSet<>();
numbers.add(2);
numbers.add(5);
numbers.add(6);
System.out.println("TreeSet: " + numbers);
// Using the first() method
int first = numbers.first();
System.out.println("First Number: " + first);
// Using the last() method
int last = numbers.last();
System.out.println("Last Number: " + last);
}
}
Saída
TreeSet: [2, 5, 6] First Number: 2 Last Number: 6
2. Métodos teto(), piso(), superior() e inferior()
- maior(elemento) - Retorna o elemento mais baixo entre os elementos que são maiores que o especificado
element. - inferior(elemento) - Retorna o maior elemento entre os elementos que são menores que o especificado
element. - teto(elemento) - Retorna o elemento mais baixo entre os elementos que são maiores que o elemento especificado . Se o elemento passado existe em um conjunto de árvore, ele retorna o
elementpassado como um argumento. - piso(elemento) - Retorna o maior elemento entre os elementos que são menores que os
elementespecificados . Se o elemento passado existe em um conjunto de árvore, ele retorna oelementpassado como um argumento.
Por exemplo,
import java.util.TreeSet;
class Main {
public static void main(String[] args) {
TreeSet<Integer> numbers = new TreeSet<>();
numbers.add(2);
numbers.add(5);
numbers.add(4);
numbers.add(6);
System.out.println("TreeSet: " + numbers);
// Using higher()
System.out.println("Using higher: " + numbers.higher(4));
// Using lower()
System.out.println("Using lower: " + numbers.lower(4));
// Using ceiling()
System.out.println("Using ceiling: " + numbers.ceiling(4));
// Using floor()
System.out.println("Using floor: " + numbers.floor(3));
}
}
Saída
TreeSet: [2, 4, 5, 6] Using higher: 5 Using lower: 2 Using ceiling: 4 Using floor: 2
3. Métodos pollfirst() e pollLast()
pollFirst()- retorna e remove o primeiro elemento do conjuntopollLast()- retorna e remove o último elemento do conjunto
Por exemplo,
import java.util.TreeSet;
class Main {
public static void main(String[] args) {
TreeSet<Integer> numbers = new TreeSet<>();
numbers.add(2);
numbers.add(5);
numbers.add(4);
numbers.add(6);
System.out.println("TreeSet: " + numbers);
// Using pollFirst()
System.out.println("Removed First Element: " + numbers.pollFirst());
// Using pollLast()
System.out.println("Removed Last Element: " + numbers.pollLast());
System.out.println("New TreeSet: " + numbers);
}
}
Saída
TreeSet: [2, 4, 5, 6] Removed First Element: 2 Removed Last Element: 6 New TreeSet: [4, 5]
4. Métodos headSet(), tailSet() e subSet()
headSet(elemento, valor booleano)
O
headSet() retorna todos os elementos de uma árvore antes do elemento especificado (que é passado como um argumento). O booleanValue parâmetro é opcional. Seu valor padrão é
false . Se
true é passado como um booleanValue , o método retorna todos os elementos antes do elemento especificado, incluindo o elemento especificado. Por exemplo,
import java.util.TreeSet;
class Main {
public static void main(String[] args) {
TreeSet<Integer> numbers = new TreeSet<>();
numbers.add(2);
numbers.add(5);
numbers.add(4);
numbers.add(6);
System.out.println("TreeSet: " + numbers);
// Using headSet() with default boolean value
System.out.println("Using headSet without boolean value: " + numbers.headSet(5));
// Using headSet() with specified boolean value
System.out.println("Using headSet with boolean value: " + numbers.headSet(5, true));
}
}
Saída
TreeSet: [2, 4, 5, 6] Using headSet without boolean value: [2, 4] Using headSet with boolean value: [2, 4, 5]
tailSet(elemento, valor booleano)
O
tailSet() O método retorna todos os elementos de uma árvore definida após o elemento especificado (que é passado como parâmetro) incluindo o elemento especificado . O booleanValue parâmetro é opcional. Seu valor padrão é
true . Se
false é passado como um booleanValue , o método retorna todos os elementos após o elemento especificado sem incluir o elemento especificado . Por exemplo,
import java.util.TreeSet;
class Main {
public static void main(String[] args) {
TreeSet<Integer> numbers = new TreeSet<>();
numbers.add(2);
numbers.add(5);
numbers.add(4);
numbers.add(6);
System.out.println("TreeSet: " + numbers);
// Using tailSet() with default boolean value
System.out.println("Using tailSet without boolean value: " + numbers.tailSet(4));
// Using tailSet() with specified boolean value
System.out.println("Using tailSet with boolean value: " + numbers.tailSet(4, false));
}
}
Saída
TreeSet: [2, 4, 5, 6] Using tailSet without boolean value: [4, 5, 6] Using tailSet with boolean value: [5, 6]
subconjunto(e1, bv1, e2, bv2)
O
subSet() retorna todos os elementos entre e1 e e2 incluindo e1 . O bv1 e bv2 são parâmetros opcionais. O valor padrão de bv1 é
true , e o valor padrão de bv2 é false . Se
false é passado como bv1 , o método retorna todos os elementos entre e1 e e2 sem incluir e1 . Se
true é passado como bv2 , o método retorna todos os elementos entre e1 e e2 , incluindo e1 . Por exemplo,
import java.util.TreeSet;
class Main {
public static void main(String[] args) {
TreeSet<Integer> numbers = new TreeSet<>();
numbers.add(2);
numbers.add(5);
numbers.add(4);
numbers.add(6);
System.out.println("TreeSet: " + numbers);
// Using subSet() with default boolean value
System.out.println("Using subSet without boolean value: " + numbers.subSet(4, 6));
// Using subSet() with specified boolean value
System.out.println("Using subSet with boolean value: " + numbers.subSet(4, false, 6, true));
}
}
Saída
TreeSet: [2, 4, 5, 6] Using subSet without boolean value: [4, 5] Using subSet with boolean value: [5, 6]
Definir operações
Os métodos do
TreeSet A classe também pode ser usada para executar várias operações de conjunto. União de Conjuntos
Para realizar a união entre dois conjuntos, usamos o
addAll() método. Por exemplo,
import java.util.TreeSet;;
class Main {
public static void main(String[] args) {
TreeSet<Integer> evenNumbers = new TreeSet<>();
evenNumbers.add(2);
evenNumbers.add(4);
System.out.println("TreeSet1: " + evenNumbers);
TreeSet<Integer> numbers = new TreeSet<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
System.out.println("TreeSet2: " + numbers);
// Union of two sets
numbers.addAll(evenNumbers);
System.out.println("Union is: " + numbers);
}
}
Saída
TreeSet1: [2, 4] TreeSet2: [1, 2, 3] Union is: [1, 2, 3, 4]
Intersecção de conjuntos
Para realizar a interseção entre dois conjuntos, usamos o
retainAll() método. Por exemplo,
import java.util.TreeSet;;
class Main {
public static void main(String[] args) {
TreeSet<Integer> evenNumbers = new TreeSet<>();
evenNumbers.add(2);
evenNumbers.add(4);
System.out.println("TreeSet1: " + evenNumbers);
TreeSet<Integer> numbers = new TreeSet<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
System.out.println("TreeSet2: " + numbers);
// Intersection of two sets
numbers.retainAll(evenNumbers);
System.out.println("Intersection is: " + numbers);
}
}
Saída
TreeSet1: [2, 4] TreeSet2: [1, 2, 3] Intersection is: [2]
Diferença de conjuntos
Para calcular a diferença entre os dois conjuntos, podemos usar o
removeAll() método. Por exemplo,
import java.util.TreeSet;;
class Main {
public static void main(String[] args) {
TreeSet<Integer> evenNumbers = new TreeSet<>();
evenNumbers.add(2);
evenNumbers.add(4);
System.out.println("TreeSet1: " + evenNumbers);
TreeSet<Integer> numbers = new TreeSet<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);
System.out.println("TreeSet2: " + numbers);
// Difference between two sets
numbers.removeAll(evenNumbers);
System.out.println("Difference is: " + numbers);
}
}
Saída
TreeSet1: [2, 4] TreeSet2: [1, 2, 3, 4] Difference is: [1, 3]
Subconjunto de um conjunto
Para verificar se um conjunto é um subconjunto de outro conjunto ou não, usamos o
containsAll() método. Por exemplo,
import java.util.TreeSet;
class Main {
public static void main(String[] args) {
TreeSet<Integer> numbers = new TreeSet<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);
System.out.println("TreeSet1: " + numbers);
TreeSet<Integer> primeNumbers = new TreeSet<>();
primeNumbers.add(2);
primeNumbers.add(3);
System.out.println("TreeSet2: " + primeNumbers);
// Check if primeNumbers is subset of numbers
boolean result = numbers.containsAll(primeNumbers);
System.out.println("Is TreeSet2 subset of TreeSet1? " + result);
}
}
Saída
TreeSet1: [1, 2, 3, 4] TreeSet2: [2, 3] Is TreeSet2 subset of TreeSet1? True
Outros métodos de TreeSet
| Método | Descrição |
|---|---|
clone() | Cria uma cópia do TreeSet |
contains() | Pesquisa o TreeSet pelo elemento especificado e retorna um resultado booleano |
isEmpty() | Verifica se o TreeSet está vazio |
size() | Retorna o tamanho do TreeSet |
clear() | Remove todos os elementos do TreeSet |
Para saber mais, visite Java TreeSet (documentação oficial do Java).
TreeSet vs. Conjunto de hash
Tanto o
TreeSet bem como o HashSet implementa o Set interface. No entanto, existem algumas diferenças entre eles. - Diferente de
HashSet, elementos emTreeSetsão armazenados em alguma ordem. É porqueTreeSetimplementa oSortedSetinterface também. TreeSetfornece alguns métodos para facilitar a navegação. Por exemplo,first(),last(),headSet(),tailSet(), etc. É porqueTreeSettambém implementa oNavigableSetinterface.HashSeté mais rápido que oTreeSetpara operações básicas como adicionar, remover, conter e dimensionar.
Comparador de TreeSet
Em todos os exemplos acima, os elementos do conjunto de árvores são classificados naturalmente. No entanto, também podemos personalizar a ordenação dos elementos.
Para isso, precisamos criar nossa própria classe comparadora com base em quais elementos em um conjunto de árvore são classificados. Por exemplo,
import java.util.TreeSet;
import java.util.Comparator;
class Main {
public static void main(String[] args) {
// Creating a tree set with customized comparator
TreeSet<String> animals = new TreeSet<>(new CustomComparator());
animals.add("Dog");
animals.add("Zebra");
animals.add("Cat");
animals.add("Horse");
System.out.println("TreeSet: " + animals);
}
// Creating a comparator class
public static class CustomComparator implements Comparator<String> {
@Override
public int compare(String animal1, String animal2) {
int value = animal1.compareTo(animal2);
// elements are sorted in reverse order
if (value > 0) {
return -1;
}
else if (value < 0) {
return 1;
}
else {
return 0;
}
}
}
}
Saída
TreeSet: [Zebra, Horse, Dog, Cat]
No exemplo acima, criamos um conjunto de árvore passando CustomComparator classe como argumento.
O Comparador Personalizado classe implementa o
Comparator interface. Em seguida, substituímos o
compare() método. O método agora classificará os elementos na ordem inversa. Para saber mais, visite Java Comparator (documentação oficial do Java).
Java