Java TreeSet

Neste tutorial, vamos aprender com exemplos a classe Java TreeSet e suas várias operações e métodos.

A classe TreeSet do Java Collection Framework fornece funcionalidades de estrutura de dados de árvore.

Ela estendeInterface NavigableSet。

Criar um conjunto de árvores

Para criar um conjunto de árvores, devemos primeiro importar o pacote java.util.TreeSet.

Após a importação do pacote, vamos ver como criar um TreeSet em Java.

TreeSet<Integer> numbers = new TreeSet<>();

Aqui, criamos um TreeSet sem parâmetros. No exemplo, os elementos do TreeSet são ordenados naturalmente (em ordem crescente).

Mas, podemos usar o interface Comparator para personalizar a ordenação dos elementos. Vamos aprender isso na parte posterior do tutorial.

métodos TreeSet

A classe TreeSet oferece várias métodos que permitem que executemos várias operações na coleção.

inserir elemento no TreeSet

• add() - inserir o elemento especificado na coleção

• addAll() - inserir todos os elementos do conjunto especificado na coleção

例如，

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> evenNumbers = new TreeSet<>();
　　　　　　　　//　usar o método add()
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　evenNumbers.add(6);
　　　　　　　　System.out.println("TreeSet: "　+　evenNumbers);
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　//　usar o método addAll()
　　　　　　　　numbers.addAll(evenNumbers);
　　　　　　　　System.out.println("Novo TreeSet:　"　+　numbers);
　　　　}
}

Resultados de saída

TreeSet: [2,　4,　6]
Novo TreeSet:　[1,　2,　4,　6]

acessar elementos TreeSet

Para acessar os elementos do TreeSet, podemos usar o método iterator(). Para usar este método, devemos importar o pacote java.util.Iterator. 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);
　　　　　　　　//　chamar o método iterator()
　　　　　　　　Iterator<Integer> iterate = numbers.iterator();
　　　　　　　　System.out.print("TreeSet usa iterador: ")
　　　　　　　　//acessar elemento
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Resultados de saída

TreeSet: [2,　5,　6]
TreeSet usa iterador:　2,　5,　6,

remover elemento

• remove() - remover o elemento especificado da coleção

• removeAll() - remover todos os elementos da coleção

例如，

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);
　　　　　　　　//　usar o método remove()
　　　　　　　　boolean value1　= numbers.remove(5);
　　　　　　　　System.out.println("5Foi removido? "　+　value1);
　　　　　　　　//　usar o método removeAll()
　　　　　　　　boolean value2　= numbers.removeAll(numbers);
　　　　　　　　System.out.println("Removemos todos os elementos? ")　+　value2);
　　　　}
}

Resultados de saída

TreeSet: [2,　5,　6]
5Foi removido? true
Removemos todos os elementos? true

métodos de navegação

Porque a classe TreeSet implementou NavigableSet, ela fornece várias métodos para navegar pelos elementos do conjunto.

1. first() e last() métodos

• first() - retorna o primeiro elemento da coleção

• last() - retorna o último elemento da coleção

例如，

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);
　　　　　　　　//　usar o método first()
　　　　　　　　int first = numbers.first();
　　　　　　　　System.out.println("primeiro número: "　+　primeiro);
　　　　　　　　//　Usar o método　last()
　　　　　　　　int last = numbers.last();
　　　　　　　　System.out.println("Último número:　"　+　last);
　　　　}
}

Resultados de saída

TreeSet: [2,　5,　6]
Primeiro número:　2
Último número:　6

2. ceiling(), floor(), higher() e lower() métodos

• Higher(element) - Retornar o menor elemento maior que o elemento especificado (element).

• lower(element) - Retornar o maior elemento menor que o elemento especificado (element).

• ceiling(element) - Retornar o menor elemento maior que o elemento especificado (element). Se o elemento (element) existir no conjunto de árvores, retornar o elemento (element) passado como parâmetro.

• floor(element) - Retornar o maior elemento menor que o elemento especificado (element). Se o elemento (element) existir no conjunto de árvores, retornar o elemento (element) passado como parâmetro.

例如，

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);
　　　　　　　　//　Usar　higher()
　　　　　　　　System.out.println("Usar　higher:　"　+　numbers.higher(4);
　　　　　　　　//　Usar　lower()
　　　　　　　　System.out.println("Usar　lower:　"　+　numbers.lower(4);
　　　　　　　　//　Usar　ceiling()
　　　　　　　　System.out.println("Usar　ceiling:　"　+　numbers.ceiling(4);
　　　　　　　　//　Usar　floor()
　　　　　　　　System.out.println("Usar　floor:　"　+　numbers.floor(3);
　　　　}
}

Resultados de saída

TreeSet: [2,　4,　5,　6]
Usar　higher:　5
Usar　lower:　2
Usar　ceiling:　4
Usar　floor:　2

3. pollfirst() e pollLast() métodos

• pollFirst() - Retornar e remover o primeiro elemento da coleção

• pollLast() - Retornar e remover o último elemento da coleção

例如，

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);
　　　　　　　　//　Usar　pollFirst()
　　　　　　　　System.out.println("Remover o primeiro elemento:　"　+　numbers.pollFirst());
　　　　　　　　//　Usar　pollLast()
　　　　　　　　System.out.println("Remover o último elemento:　"　+　numbers.pollLast());
　　　　　　　　System.out.println("Novo TreeSet:　"　+　numbers);
　　　　}
}

Resultados de saída

TreeSet: [2,　4,　5,　6]
Remover o primeiro elemento:　2
Remover o último elemento:　6
Novo TreeSet:　[4,　5]

4. headSet(), tailSet() e subSet() métodos

headSet(element,booleanValue)

headSet()方法返回指定元素（作为参数传递）之前的树集的所有元素。

booleanValue参数是可选的。默认值为false。

如果booleanValue的值为true，则该方法返回指定元素之前的所有元素，包括指定元素。

例如，

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);
　　　　　　　　//　使用 headSet()使用默认的布尔值
　　　　　　　　System.out.println("使用不带布尔值的headSet: " +)　+　numbers.headSet(5);
　　　　　　　　//　使用 headSet()使用指定的布尔值
　　　　　　　　System.out.println("将headSet与布尔值一起使用: " +)　+　numbers.headSet(5, true));
　　　　}
}

Resultados de saída

TreeSet: [2,　4,　5,　6]
使用不带布尔值的headSet: [2,　4]
将headSet与布尔值一起使用: [2,　4,　5]

tailSet(element,booleanValue)

tailSet()方法返回包含指定元素的指定元素（作为参数传递）之后的树集的所有元素。

booleanValue参数是可选的。默认值为true。

如果false作为a传递booleanValue，则该方法将返回指定后的所有元素，element而不包括指定的element。

例如，

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);
　　　　　　　　//　使用 tailSet()使用默认的布尔值
　　　　　　　　System.out.println("tailSet()使用默认的布尔值: " +)　+　numbers.tailSet(4);
　　　　　　　　//　使用 tailSet() with specified boolean value
　　　　　　　　System.out.println("tailSet()带有布尔值: " +)　+　numbers.tailSet(4, false));
　　　　}
}

Resultados de saída

TreeSet: [2,　4,　5,　6]
使用 tailSet()使用默认的布尔值: [4,　5,　6]
tailSet()带有布尔值: [5,　6]

subSet(e1,bv1,e2,bv2)

subSet()方法返回e1和e2之间的所有元素，包括e1。

bv1和bv2是可选参数。 　bv1的默认值为true，bv2的默认值为false。

如果将false作为bv1传递，则该方法返回e1和e2之间的所有元素，而不包括e1。

如果将true作为bv2传递，则该方法返回e1和e2之间的所有元素，包括e1。

例如，

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);
　　　　　　　　//　使用 subSet() with default boolean value
　　　　　　　　System.out.println("subSet()使用默认布尔值: " +)　+　numbers.subSet(4,　6);
　　　　　　　　//　Usando subSet() com valor booleano especificado
　　　　　　　　System.out.println("subSet() usando o valor booleano especificado: ",　+　numbers.subSet(4, false,　6, true));
　　　　}
}

Resultados de saída

TreeSet: [2,　4,　5,　6]
subSet() usando o valor booleano padrão: [4,　5]
subSet() usando o valor booleano especificado: [5,　6]

Métodos de operação de conjunto

Os métodos da classe TreeSet podem ser usados para realizar várias operações de conjunto.

União do conjunto

Para realizar a união entre dois conjuntos, usamos o método addAll(). 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("Árvore de conjunto",1: "　+　evenNumbers);
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("Árvore de conjunto",2: "　+　numbers);
　　　　　　　　//União de dois conjuntos
　　　　　　　　numbers.addAll(evenNumbers);
　　　　　　　　System.out.println("União é: ",　+　numbers);
　　　　}
}

Resultados de saída

TreeSet1: [2,　4]
TreeSet2: [1,　2,　3]
União: [1,　2,　3,　4]

Interseção do conjunto

Para realizar a interseção entre dois conjuntos, usamos o método retainAll(). 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("Árvore de conjunto",1: "　+　evenNumbers);
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("Árvore de conjunto",2: "　+　numbers);
　　　　　　　　//　Interseção de dois conjuntos
　　　　　　　　numbers.retainAll(evenNumbers);
　　　　　　　　System.out.println("Interseção do conjunto: ",　+　numbers);
　　　　}
}

Resultados de saída

TreeSet1: [2,　4]
TreeSet2: [1,　2,　3]
Interseção do conjunto: [2]

Diferença do conjunto

Para calcular a diferença entre dois conjuntos, podemos usar o método removeAll(). 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("Árvore de conjunto",1: "　+　evenNumbers);
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　numbers.add(4);
　　　　　　　　System.out.println("Árvore de conjunto",2: "　+　numbers);
　　　　　　　　//Diferença do conjunto
　　　　　　　　numbers.removeAll(evenNumbers);
　　　　　　　　System.out.println("Diferença: ",　+　numbers);
　　　　}
}

Resultados de saída

TreeSet1: [2,　4]
TreeSet2: [1,　2,　3,　4]
Diferença: [1,　3]

Subconjunto do conjunto

Para verificar se um conjunto é subconjunto de outro, usamos o método containsAll(). 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("Árvore de conjunto",1: "　+　numbers);
　　　　　　　　TreeSet<Integer> primeNumbers = new TreeSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　System.out.println("Árvore de conjunto",2: "　+　primeNumbers);
　　　　　　　　//Verificar se primeNumbers é um subconjunto de numbers
　　　　　　　　boolean result = numbers.containsAll(primeNumbers);
　　　　　　　　System.out.println("Árvore de conjunto",2É um TreeSet1É um subconjunto? "　+　result);
　　　　}
}

Resultados de saída

TreeSet1: [1,　2,　3,　4]
TreeSet2: [2,　3]
TreeSet2É um TreeSet1É um subconjunto? True

Outros métodos TreeSet

TreeSet vs. HashSet

TreeSet e HashSet implementam a interface Set. No entanto, há algumas diferenças entre eles.

• Diferente do HashSet, os elementos no TreeSet são armazenados em uma certa ordem. Isso é porque TreeSet também implementa a interface SortedSet.

• TreeSet oferece alguns métodos fáceis de navegar. Por exemplo first(), last(), headSet(), tailSet() e outros. Isso é porque TreeSet também implementa a interface NavigableSet.

• Para operações básicas como adicionar, remover, incluir e tamanho, HashSet é mais rápido do que TreeSet.

Comparador TreeSet

Em todos os exemplos acima, os elementos do conjunto de árvores são ordenados naturalmente. Mas também podemos personalizar a ordem dos elementos.

Para isso, precisamos criar nossa classe comparator, baseada na ordenação dos elementos do conjunto de árvores. Por exemplo

import java.util.TreeSet;
import java.util.Comparator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Criar um TreeSet com comparador personalizado
　　　　　　　　TreeSet<String> animals = new TreeSet<>(new CustomComparator());
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Zebra");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("TreeSet: "　+　animals);
　　　　}
　　　　//Criar uma classe comparadora
　　　　public static class CustomComparator implements Comparator<String> {
　　　　　　　　@Override
　　　　　　　　public int compare(String animal1, String animal2) {
　　　　　　　　　　　　int value = animal1.compareTo(animal2);
　　　　　　　　　　　　//Os elementos são ordenados em ordem inversa
　　　　　　　　　　　　if (value > 0) {
　　　　　　　　　　　　　　　　return　-1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else if (value < 0) {
　　　　　　　　　　　　　　　　return　1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else {
　　　　　　　　　　　　　　　　return 0;
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

Resultados de saída

TreeSet: [Zebra, Cavalo, Cão, Gato]

No exemplo acima, criamos um TreeSet e passamos a classe CustomComparator como parâmetro.

A classe CustomComparator implementa a interface Comparator.

Então, nós sobrescrevemos o método compare(). Agora, esse método ordenará os elementos em ordem inversa.