Java TreeSet

En este tutorial, aprenderemos a través de ejemplos la clase Java TreeSet y sus diversas operaciones y métodos.

La clase TreeSet del Java Collection Framework proporciona las funciones de estructura de datos de árbol.

ExtiendeInterfaz NavigableSet。

Crear un conjunto de árboles

Para crear un conjunto de árboles, primero debemos importar el paquete java.util.TreeSet.

Después de importar el paquete, a continuación se muestra cómo crear un TreeSet en Java.

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

Aquí, creamos un TreeSet sin parámetros. En este ejemplo, los elementos del TreeSet se ordenan naturalmente (ascendente).

Sin embargo, podemos usar el interfaz Comparator para personalizar el orden de los elementos. Vamos a aprenderlo en la parte posterior de este tutorial.

métodos de TreeSet

La clase TreeSet proporciona varios métodos que permiten realizar varias operaciones en la colección.

insertar el elemento en TreeSet

• add() - insertar el elemento especificado en la colección

• addAll() - insertar todos los elementos de la colección especificada en la colección

por ejemplo,

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer>　evenNumbers　=　new　TreeSet<>();
　　　　　　　　//　usar el 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 el método addAll()
　　　　　　　　numbers.addAll(evenNumbers);
　　　　　　　　System.out.println("nuevo TreeSet:　"　+　numbers);
　　　　}
}

Resultados de salida

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

acceder a los elementos de TreeSet

Para acceder a los elementos de TreeSet, podemos usar el método iterator(). Para usar este método, debemos importar el paquete java.util.Iterator. Por ejemplo,

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);
　　　　　　　　//　llamar al método iterator()
　　　　　　　　Iterator<Integer> iterate = numbers.iterator();
　　　　　　　　System.out.print("TreeSet utiliza el iterador: " + "\t"
　　　　　　　　//acceder a los elementos
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Resultados de salida

TreeSet: [2,　5,　6]
TreeSet utiliza el iterador:　2,　5,　6,

eliminar el elemento

• remove() - eliminar el elemento especificado de la colección

• removeAll() - eliminar todos los elementos de la colección

por ejemplo,

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 el método remove()
　　　　　　　　boolean value1　= numbers.remove(5);
　　　　　　　　System.out.println("5¿Fue eliminado? "　+　value1);
　　　　　　　　//　usar el método removeAll()
　　　　　　　　boolean value2　= numbers.removeAll(numbers);
　　　　　　　　System.out.println("¿Se eliminaron todos los elementos? " + "\t"　+　value2);
　　　　}
}

Resultados de salida

TreeSet: [2,　5,　6]
5¿Fue eliminado? true
¿Se eliminaron todos los elementos? true

métodos de navegación

Debido a que la clase TreeSet implementa NavigableSet, proporciona varios métodos para navegar por los elementos del conjunto.

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

• first() - devuelve el primer elemento de la colección

• last() - devuelve el último elemento de la colección

por ejemplo,

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

Resultados de salida

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

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

• Higher(elemento) - devolver el elemento más pequeño que es mayor que el elemento especificado (elemento).

• lower(elemento) - devolver el elemento más grande que es menor que el elemento especificado (elemento).

• ceiling(elemento) - devolver el elemento más pequeño que es mayor que el elemento especificado (elemento). Si el elemento especificado (elemento) existe en el conjunto de árboles, devuelve el elemento (elemento) como parámetro pasado.

• floor(elemento) - devolver el elemento más grande que es menor que el elemento especificado (elemento). Si el elemento especificado (elemento) existe en el conjunto de árboles, devuelve el elemento (elemento) como parámetro pasado.

por ejemplo,

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 salida

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

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

• pollFirst() - devolver y eliminar el primer elemento de la colección

• pollLast() - devolver y eliminar el último elemento de la colección

por ejemplo,

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("eliminar el primer elemento:　"　+　numbers.pollFirst());
　　　　　　　　//　usar　pollLast()
　　　　　　　　System.out.println("eliminar el último elemento:　"　+　numbers.pollLast());
　　　　　　　　System.out.println("nuevo TreeSet:　"　+　numbers);
　　　　}
}

Resultados de salida

TreeSet: [2,　4,　5,　6]
eliminar el primer elemento:　2
eliminar el último elemento:　6
nuevo TreeSet:　[4,　5]

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

headSet(element,booleanValue)

el método headSet() devuelve todos los elementos del conjunto de árboles antes del elemento especificado (como parámetro pasado).

el parámetro booleanValue es opcional. El valor predeterminado es false.

si el valor de booleanValue es true, este método devuelve todos los elementos antes del elemento especificado, incluyendo el elemento especificado.

por ejemplo,

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 headSet() con valor booleano predeterminado
　　　　　　　　System.out.println("usar headSet sin valor booleano: "　+　numbers.headSet(5));
　　　　　　　　//　usar headSet() con valor booleano especificado
　　　　　　　　System.out.println("usar headSet con valor booleano: "　+　numbers.headSet(5, true));
　　　　}
}

Resultados de salida

TreeSet: [2,　4,　5,　6]
usar headSet sin valor booleano: [2,　4]
usar headSet con valor booleano: [2,　4,　5]

tailSet(element,booleanValue)

el método tailSet() devuelve todos los elementos del conjunto de árboles que contienen el elemento especificado (como parámetro pasado) después del elemento especificado.

el parámetro booleanValue es opcional. El valor predeterminado es true.

si false se transmite como booleanValue, este método devolverá todos los elementos especificados, element sin incluir el elemento especificado.

por ejemplo,

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 tailSet() con valor booleano predeterminado
　　　　　　　　System.out.println("tailSet() con valor booleano predeterminado: "　+　numbers.tailSet(4));
　　　　　　　　//　usar tailSet() con valor booleano especificado
　　　　　　　　System.out.println("tailSet() con valor booleano: "　+　numbers.tailSet(4, false));
　　　　}
}

Resultados de salida

TreeSet: [2,　4,　5,　6]
usar tailSet() con valor booleano predeterminado: [4,　5,　6]
tailSet() con valor booleano: [5,　6]

subSet(e1,bv1,e2,bv2)

el método subSet() devuelve e1y e2todos los elementos entre1。

bv1y bv2es un parámetro opcional. 　bv1el valor predeterminado es true, bv2el valor predeterminado es false.

si se transmite false como bv1si se transmite, este método devuelve e1y e2todos los elementos entre, sin incluir e1。

si se transmite true como bv2si se transmite, este método devuelve e1y e2todos los elementos entre1。

por ejemplo,

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 subSet() con valor booleano predeterminado
　　　　　　　　System.out.println("subSet() utiliza el valor booleano predeterminado: "　+　numbers.subSet(4,　6));
　　　　　　　　//　使用　subSet()　使用指定的布尔值
　　　　　　　　System.out.println("subSet()使用指定的布尔值:　"　+　numbers.subSet(4,　false,　6, true));
　　　　}
}

Resultados de salida

TreeSet: [2,　4,　5,　6]
subSet() utiliza el valor booleano por defecto: [4,　5]
subSet() utiliza el valor booleano especificado: [5,　6]

Métodos de operaciones de conjunto

Los métodos de la clase TreeSet se pueden usar para realizar varias operaciones de conjunto.

Unión del conjunto

Para realizar la unión entre dos conjuntos, utilizamos el método addAll(). Por ejemplo,

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("Arbol", "第2段":"boolean result = numbers.containsAll(primeNumbers);", "第3段":"Verificar si primeNumbers es un subconjunto de numbers", "第4段":"primeNumbers);", "第5段":": "", "第6段":"primeNumbers.add("1　+　evenNumbers);
　　　　　　　　TreeSet<Integer>　numbers　=　new　TreeSet<>();
　　　　　　　　numbers.add("1);
　　　　　　　　numbers.add("2);
　　　　　　　　numbers.add("3);
　　　　　　　　System.out.println("Arbol", "第2段":"boolean result = numbers.containsAll(primeNumbers);", "第3段":"Verificar si primeNumbers es un subconjunto de numbers", "第4段":"primeNumbers);", "第5段":": "", "第6段":"primeNumbers.add("2　+　numbers);
　　　　　　　　//Unión de dos conjuntos
　　　　　　　　numbers.addAll(evenNumbers);
　　　　　　　　System.out.println("Unión es: ",　+　numbers);
　　　　}
}

Resultados de salida

TreeSet1: [2,　4]
TreeSet2: [1,　2,　3]
Unión: [1,　2,　3,　4]

Intersección del conjunto

Para realizar la intersección entre dos conjuntos, utilizamos el método retainAll(). Por ejemplo,

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("Arbol", "第2段":"boolean result = numbers.containsAll(primeNumbers);", "第3段":"Verificar si primeNumbers es un subconjunto de numbers", "第4段":"primeNumbers);", "第5段":": "", "第6段":"primeNumbers.add("1　+　evenNumbers);
　　　　　　　　TreeSet<Integer>　numbers　=　new　TreeSet<>();
　　　　　　　　numbers.add("1);
　　　　　　　　numbers.add("2);
　　　　　　　　numbers.add("3);
　　　　　　　　System.out.println("Arbol", "第2段":"boolean result = numbers.containsAll(primeNumbers);", "第3段":"Verificar si primeNumbers es un subconjunto de numbers", "第4段":"primeNumbers);", "第5段":": "", "第6段":"primeNumbers.add("2　+　numbers);
　　　　　　　　//　Intersección de dos conjuntos
　　　　　　　　numbers.retainAll(evenNumbers);
　　　　　　　　System.out.println("Intersección del conjunto: ",　+　numbers);
　　　　}
}

Resultados de salida

TreeSet1: [2,　4]
TreeSet2: [1,　2,　3]
Intersección del conjunto: [2]

Diferencia del conjunto

Para calcular la diferencia entre dos conjuntos, podemos usar el método removeAll(). Por ejemplo,

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("Arbol", "第2段":"boolean result = numbers.containsAll(primeNumbers);", "第3段":"Verificar si primeNumbers es un subconjunto de numbers", "第4段":"primeNumbers);", "第5段":": "", "第6段":"primeNumbers.add("1　+　evenNumbers);
　　　　　　　　TreeSet<Integer>　numbers　=　new　TreeSet<>();
　　　　　　　　numbers.add("1);
　　　　　　　　numbers.add("2);
　　　　　　　　numbers.add("3);
　　　　　　　　numbers.add("4);
　　　　　　　　System.out.println("Arbol", "第2段":"boolean result = numbers.containsAll(primeNumbers);", "第3段":"Verificar si primeNumbers es un subconjunto de numbers", "第4段":"primeNumbers);", "第5段":": "", "第6段":"primeNumbers.add("2　+　numbers);
　　　　　　　　//Diferencia del conjunto
　　　　　　　　numbers.removeAll(evenNumbers);
　　　　　　　　System.out.println("Diferencia: ",　+　numbers);
　　　　}
}

Resultados de salida

TreeSet1: [2,　4]
TreeSet2: [1,　2,　3,　4]
Diferencia: [1,　3]

Subconjunto del conjunto

Para verificar si un conjunto es un subconjunto de otro, utilizamos el método containsAll(). Por ejemplo,

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("Arbol", "第2段":"boolean result = numbers.containsAll(primeNumbers);", "第3段":"Verificar si primeNumbers es un subconjunto de numbers", "第4段":"primeNumbers);", "第5段":": "", "第6段":"primeNumbers.add("1　+　numbers);
　　　　　　　　TreeSet<Integer>　primeNumbers　=　new　TreeSet<>();
　　　　　　　　2);
　　　　　　　　3);
　　　　　　　　System.out.println("Arbol", "第2段":"boolean result = numbers.containsAll(primeNumbers);", "第3段":"Verificar si primeNumbers es un subconjunto de numbers", "第4段":"primeNumbers);", "第5段":": "", "第6段":"primeNumbers.add("2　+　
　　　　　　　　//
　　　　　　　　
　　　　　　　　System.out.println("Arbol", "第2段":"boolean result = numbers.containsAll(primeNumbers);", "第3段":"Verificar si primeNumbers es un subconjunto de numbers", "第4段":"primeNumbers);", "第5段":": "", "第6段":"primeNumbers.add("2Es TreeSet1¿Es un subconjunto? "　+　result);
　　　　}
}

Resultados de salida

TreeSet1: [1,　2,　3,　4]
TreeSet2: [2,　3]
TreeSet2Es TreeSet1¿Es un subconjunto? True

Otros métodos de TreeSet

TreeSet vs. HashSet

TreeSet y HashSet implementan la interfaz Set. Sin embargo, hay algunas diferencias entre ellos.

• A diferencia de HashSet, los elementos en TreeSet se almacenan en un orden determinado. Esto se debe a que TreeSet también implementa la interfaz SortedSet.

• TreeSet proporciona algunos métodos fáciles de navegar. Por ejemplo first(), last(), headSet(), tailSet() y otros. Esto se debe a que TreeSet también implementa la interfaz NavigableSet.

• Para operaciones básicas como agregar, eliminar, contener y tamaño, HashSet es más rápido que TreeSet.

Comparador de TreeSet

En todos los ejemplos anteriores, los elementos del conjunto de árboles están ordenados de manera natural. Pero también podemos personalizar el orden de los elementos.

Para esto, necesitamos crear nuestra propia clase comparator, basada en ordenar los elementos del conjunto de árboles. Por ejemplo

import java.util.TreeSet;
import java.util.Comparator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Crear un TreeSet con un 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);
　　　　}
　　　　//Crear una clase comparadora
　　　　public static class CustomComparator implements Comparator<String> {
　　　　　　　　@Override
　　　　　　　　public　int　compare(String　animal1,　String　animal2)　{
　　　　　　　　　　　　int　value　=　　animal1.compareTo(animal2);
　　　　　　　　　　　　//Los elementos se ordenan en orden inverso
　　　　　　　　　　　　if　(value　>　0)　{
　　　　　　　　　　　　　　　　return　-1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else　if　(value　<　0)　{
　　　　　　　　　　　　　　　　return　1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else　{
　　　　　　　　　　　　　　　　return　0;
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

Resultados de salida

TreeSet:　[Zebra,　Horse,　Dog,　Cat]

En el ejemplo anterior, creamos un conjunto de árboles y pasamos la clase CustomComparator como parámetro.

La clase CustomComparator implementa la interfaz Comparator.

Luego, volvemos a escribir el método compare(). Ahora, este método ordenará los elementos en orden inverso.