Conjunto de árbol de Java
Conjunto de árboles de Java
En este tutorial, aprenderemos sobre la clase Java TreeSet y sus diversas operaciones y métodos con la ayuda de ejemplos.
El TreeSet La clase del marco de colecciones de Java proporciona la funcionalidad de una estructura de datos de árbol.
Extiende la interfaz NavigableSet.
Creación de un TreeSet
Para crear un conjunto de árboles, debemos importar el java.util.TreeSet paquete primero.
Una vez que importamos el paquete, así es como podemos crear un TreeSet en Java.
TreeSet<Integer> numbers = new TreeSet<>();
Aquí, hemos creado un TreeSet sin ningún argumento. En este caso, los elementos en TreeSet se ordenan naturalmente (orden ascendente).
Sin embargo, podemos personalizar la clasificación de los elementos usando el Comparator interfaz. Aprenderemos sobre esto más adelante en este tutorial.
Métodos de TreeSet
El TreeSet class proporciona varios métodos que nos permiten realizar varias operaciones en el conjunto.
Insertar elementos en TreeSet
add()- inserta el elemento especificado en el conjuntoaddAll()- inserta todos los elementos de la colección especificada en el conjunto
Por ejemplo,
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);
}
}
Salida
TreeSet: [2, 4, 6] New TreeSet: [1, 2, 4, 6]
Acceso a elementos de TreeSet
Para acceder a los elementos de un conjunto de árboles, podemos usar el iterator() método. Para usar este método, debemos importar java.util.Iterator paquete. 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);
// 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(", ");
}
}
}
Salida
TreeSet: [2, 5, 6] TreeSet using Iterator: 2, 5, 6,
Eliminar elementos
remove()- elimina el elemento especificado del conjuntoremoveAll()- elimina todos los elementos del conjunto
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);
// 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);
}
}
Salida
TreeSet: [2, 5, 6] Is 5 removed? true Are all elements removed? true
Métodos de navegación
Desde el TreeSet clase implementa NavigableSet , proporciona varios métodos para navegar por los elementos del conjunto de árboles.
1. Métodos first() y last()
first()- devuelve el primer elemento del conjuntolast()- devuelve el último elemento del conjunto
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);
// 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);
}
}
Salida
TreeSet: [2, 5, 6] First Number: 2 Last Number: 6
2. Métodos de techo (), piso (), superior () y inferior ()
- superior(elemento) - Devuelve el elemento más bajo entre aquellos elementos que son mayores que el
elementespecificado . - inferior(elemento) - Devuelve el elemento mayor entre aquellos elementos que son menores que el
elementespecificado . - techo(elemento) - Devuelve el elemento más bajo entre aquellos elementos que son mayores que el elemento especificado . Si el elemento pasado existe en un conjunto de árboles, devuelve el
elementpasado como argumento. - piso(elemento) - Devuelve el elemento mayor entre aquellos elementos que son menores que el
elementespecificado . Si el elemento pasado existe en un conjunto de árboles, devuelve elelementpasado como argumento.
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);
// 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));
}
}
Salida
TreeSet: [2, 4, 5, 6] Using higher: 5 Using lower: 2 Using ceiling: 4 Using floor: 2
3. Métodos pollfirst() y pollLast()
pollFirst()- devuelve y elimina el primer elemento del conjuntopollLast()- devuelve y elimina el último elemento del conjunto
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);
// 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);
}
}
Salida
TreeSet: [2, 4, 5, 6] Removed First Element: 2 Removed Last Element: 6 New TreeSet: [4, 5]
4. Métodos headSet(), tailSet() y subSet()
headSet(elemento, valor booleano)
El headSet() El método devuelve todos los elementos de un conjunto de árboles antes del elemento especificado (que se pasa como argumento).
El valor booleano el parámetro es opcional. Su valor por defecto es false .
Si true se pasa como un booleanValue , el método devuelve todos los elementos anteriores al elemento especificado, incluido 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);
// 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));
}
}
Salida
TreeSet: [2, 4, 5, 6] Using headSet without boolean value: [2, 4] Using headSet with boolean value: [2, 4, 5]
tailSet(elemento, valor booleano)
El tailSet() El método devuelve todos los elementos de un conjunto de árboles después del element especificado (que se pasa como parámetro) incluido el elemento especificado .
El valor booleano el parámetro es opcional. Su valor por defecto es true .
Si false se pasa como un booleanValue , el método devuelve todos los elementos después del element especificado 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);
// 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));
}
}
Salida
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)
El subSet() método devuelve todos los elementos entre e1 y e2 incluyendo e1 .
El bv1 y bv2 son parámetros opcionales. El valor predeterminado de bv1 es true , y el valor predeterminado de bv2 es false .
Si false se pasa como bv1 , el método devuelve todos los elementos entre e1 y e2 sin incluir e1 .
Si true se pasa como bv2 , el método devuelve todos los elementos entre e1 y e2 , incluido e1 .
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);
// 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));
}
}
Salida
TreeSet: [2, 4, 5, 6] Using subSet without boolean value: [4, 5] Using subSet with boolean value: [5, 6]
Establecer operaciones
Los métodos del TreeSet La clase también se puede usar para realizar varias operaciones de conjuntos.
Unión de Conjuntos
Para realizar la unión entre dos conjuntos, usamos el addAll() método. 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("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);
}
}
Salida
TreeSet1: [2, 4] TreeSet2: [1, 2, 3] Union is: [1, 2, 3, 4]
Intersección de Conjuntos
Para realizar la intersección entre dos conjuntos, usamos el retainAll() método. 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("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);
}
}
Salida
TreeSet1: [2, 4] TreeSet2: [1, 2, 3] Intersection is: [2]
Diferencia de Conjuntos
Para calcular la diferencia entre los dos conjuntos, podemos usar el removeAll() método. 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("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);
}
}
Salida
TreeSet1: [2, 4] TreeSet2: [1, 2, 3, 4] Difference is: [1, 3]
Subconjunto de un Conjunto
Para verificar si un conjunto es un subconjunto de otro conjunto o no, usamos el containsAll() método. 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("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);
}
}
Salida
TreeSet1: [1, 2, 3, 4] TreeSet2: [2, 3] Is TreeSet2 subset of TreeSet1? True
Otros métodos de TreeSet
| Método | Descripción |
|---|---|
clone() | Crea una copia del TreeSet |
contains() | Busca en TreeSet el elemento especificado y devuelve un resultado booleano |
isEmpty() | Comprueba si el TreeSet está vacío |
size() | Devuelve el tamaño del TreeSet |
clear() | Elimina todos los elementos del TreeSet |
Para obtener más información, visite Java TreeSet (documentación oficial de Java).
TreeSet vs. HashSet
Tanto el TreeSet así como el HashSet implementa el Set interfaz. Sin embargo, existen algunas diferencias entre ellos.
- A diferencia de
HashSet, elementos enTreeSetse almacenan en algún orden. Es porqueTreeSetimplementa elSortedSetinterfaz también. TreeSetproporciona algunos métodos para facilitar la navegación. Por ejemplo,first(),last(),headSet(),tailSet(), etc. Es porqueTreeSettambién implementa elNavigableSetinterfaz.HashSetes más rápido que elTreeSetpara operaciones básicas como agregar, eliminar, contener y dimensionar.
Comparador TreeSet
En todos los ejemplos anteriores, los elementos del conjunto de árboles se ordenan de forma natural. Sin embargo, también podemos personalizar el orden de los elementos.
Para esto, necesitamos crear nuestra propia clase de comparación en función de qué elementos en un conjunto de árboles se ordenan. Por ejemplo,
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;
}
}
}
}
Salida
TreeSet: [Zebra, Horse, Dog, Cat]
En el ejemplo anterior, hemos creado un conjunto de árboles pasando CustomComparator class como argumento.
El Comparador Personalizado clase implementa el Comparator interfaz.
Luego anulamos el compare() método. El método ahora ordenará los elementos en orden inverso.
Para obtener más información, visite Java Comparator (documentación oficial de Java).
Java