Header Ads Widget

Ticker

6/recent/ticker-posts

Java TreeSet

En este tutorial, aprenderemos sobre la clase Java TreeSet y sus diversas operaciones y métodos con la ayuda de ejemplos.
anuncios a través de carbonoReúna a su equipo con Slack, el centro de colaboración para el trabajo.ANUNCIOS A TRAVÉS DE CARBONO
La TreeSetclase del marco de colecciones de Java proporciona la funcionalidad de una estructura de datos de árbol.
Extiende la interfaz NavigableSet .
La clase Java TreeSet implementa la interfaz NavigableSet.

Creando un TreeSet

Para crear un conjunto de hash, java.util.TreeSetprimero debemos importar el paquete.
Una vez que importamos el paquete, así es como podemos crear un TreeSeten Java.
  1. TreeSet<Integer> numbers = new TreeSet<>();
Aquí, hemos creado un TreeSetsin ningún argumento. En este caso, los elementos TreeSetse ordenan naturalmente (orden ascendente).
Sin embargo, podemos personalizar la clasificación de elementos mediante el uso de la Comparatorinterfaz. Lo aprenderemos más adelante en este tutorial.

Métodos de TreeSet

La TreeSetclase proporciona varios métodos que nos permiten realizar varias operaciones en el conjunto.

Insertar elementos en TreeSet

  • add() - inserta el elemento especificado en el conjunto
  • addAll() - inserta todos los elementos de la colección especificada en el conjunto
Por ejemplo,
  1. import java.util.TreeSet;
  2. class Main {
  3. public static void main(String[] args) {
  4. TreeSet<Integer> evenNumbers = new TreeSet<>();
  5. // Using the add() method
  6. evenNumbers.add(2);
  7. evenNumbers.add(4);
  8. evenNumbers.add(6);
  9. System.out.println("TreeSet: " + evenNumbers);
  10. TreeSet<Integer> numbers = new TreeSet<>();
  11. numbers.add(1);
  12. // Using the addAll() method
  13. numbers.addAll(evenNumbers);
  14. System.out.println("New TreeSet: " + numbers);
  15. }
  16. }
Salida
TreeSet: [2, 4, 6]
Nuevo TreeSet: [1, 2, 4, 6]

Elementos de árbol de acceso

Para acceder a los elementos de un conjunto de árbol, podemos usar el iterator()método. Para utilizar este método, debemos importar el java.util.Iteratorpaquete. Por ejemplo,
  1. import java.util.TreeSet;
  2. import java.util.Iterator;
  3. class Main {
  4. public static void main(String[] args) {
  5. TreeSet<Integer> numbers = new TreeSet<>();
  6. numbers.add(2);
  7. numbers.add(5);
  8. numbers.add(6);
  9. System.out.println("TreeSet: " + numbers);
  10. // Calling iterator() method
  11. Iterator<Integer> iterate = numbers.iterator();
  12. System.out.print("TreeSet using Iterator: ");
  13. // Accessing elements
  14. while(iterate.hasNext()) {
  15. System.out.print(iterate.next());
  16. System.out.print(", ");
  17. }
  18. }
  19. }
Salida
Conjunto de árboles: [2, 5, 6]
TreeSet usando Iterator: 2, 5, 6,

Eliminar elementos

  • remove() - elimina el elemento especificado del conjunto
  • removeAll() - elimina todos los elementos del conjunto
Por ejemplo,
  1. import java.util.TreeSet;
  2. class Main {
  3. public static void main(String[] args) {
  4. TreeSet<Integer> numbers = new TreeSet<>();
  5. numbers.add(2);
  6. numbers.add(5);
  7. numbers.add(6);
  8. System.out.println("TreeSet: " + numbers);
  9. // Using the remove() method
  10. boolean value1 = numbers.remove(5);
  11. System.out.println("Is 5 removed? " + value1);
  12. // Using the removeAll() method
  13. boolean value2 = numbers.removeAll(numbers);
  14. System.out.println("Are all elements removed? " + value2);
  15. }
  16. }
Salida
Conjunto de árboles: [2, 5, 6]
¿Se han eliminado 5? cierto
¿Se eliminan todos los elementos? cierto

Como la TreeSetclase se implementa NavigableSet, proporciona varios métodos para navegar sobre los elementos del conjunto de árbol.

1. Primero () y último () Métodos

  • first() - devuelve el primer elemento del conjunto
  • last() - devuelve el último elemento del conjunto
Por ejemplo,
  1. import java.util.TreeSet;
  2. class Main {
  3. public static void main(String[] args) {
  4. TreeSet<Integer> numbers = new TreeSet<>();
  5. numbers.add(2);
  6. numbers.add(5);
  7. numbers.add(6);
  8. System.out.println("TreeSet: " + numbers);
  9. // Using the first() method
  10. int first = numbers.first();
  11. System.out.println("First Number: " + first);
  12. // Using the last() method
  13. int last = numbers.last();
  14. System.out.println("Last Number: " + last);
  15. }
  16. }
Salida
Conjunto de árboles: [2, 5, 6]
Primer número: 2
Último número: 6

2. techo (), piso (), más alto () y más bajo () Métodos

  • higher (element) : devuelve el elemento más bajo entre los elementos que son mayores que los especificados element.
  • lower (element) : devuelve el elemento más grande entre aquellos elementos que son menores que los especificados element.
  • techo (elemento) : devuelve el elemento más bajo entre los elementos que son mayores que el elemento especificado Si el elemento pasado existe en un conjunto de árbol, devuelve el elementpasado como argumento.
  • floor (element) : devuelve el elemento más grande entre aquellos elementos que son menores que los especificados elementSi el elemento pasado existe en un conjunto de árbol, devuelve el elementpasado como argumento.
Por ejemplo,
  1. import java.util.TreeSet;
  2. class Main {
  3. public static void main(String[] args) {
  4. TreeSet<Integer> numbers = new TreeSet<>();
  5. numbers.add(2);
  6. numbers.add(5);
  7. numbers.add(4);
  8. numbers.add(6);
  9. System.out.println("TreeSet: " + numbers);
  10. // Using higher()
  11. System.out.println("Using higher: " + numbers.higher(4));
  12. // Using lower()
  13. System.out.println("Using lower: " + numbers.lower(4));
  14. // Using ceiling()
  15. System.out.println("Using ceiling: " + numbers.ceiling(4));
  16. // Using floor()
  17. System.out.println("Using floor: " + numbers.floor(3));
  18. }
  19. }
Salida
TreeSet: [2, 4, 5, 6]
Usando más alto: 5
Usando inferior: 2
Usando techo: 4
Usando piso: 2

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

  • pollFirst() - devuelve y elimina el primer elemento del conjunto
  • pollLast() - devuelve y elimina el último elemento del conjunto
Por ejemplo,
  1. import java.util.TreeSet;
  2. class Main {
  3. public static void main(String[] args) {
  4. TreeSet<Integer> numbers = new TreeSet<>();
  5. numbers.add(2);
  6. numbers.add(5);
  7. numbers.add(4);
  8. numbers.add(6);
  9. System.out.println("TreeSet: " + numbers);
  10. // Using pollFirst()
  11. System.out.println("Removed First Element: " + numbers.pollFirst());
  12. // Using pollLast()
  13. System.out.println("Removed Last Element: " + numbers.pollLast());
  14. System.out.println("New TreeSet: " + numbers);
  15. }
  16. }
Salida
TreeSet: [2, 4, 5, 6]
Primer elemento eliminado: 2
Último elemento eliminado: 6
Nuevo TreeSet: [4, 5]

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


headSet (element, booleanValue)

El headSet()método devuelve todos los elementos de un conjunto de árbol antes del elemento especificado (que se pasa como argumento).
El parámetro booleanValue es opcional. Su valor predeterminado es false.
Si truese pasa como un valor booleano , el método devuelve todos los elementos antes del elemento especificado, incluido el elemento especificado.
Por ejemplo,
  1. import java.util.TreeSet;
  2. class Main {
  3. public static void main(String[] args) {
  4. TreeSet<Integer> numbers = new TreeSet<>();
  5. numbers.add(2);
  6. numbers.add(5);
  7. numbers.add(4);
  8. numbers.add(6);
  9. System.out.println("TreeSet: " + numbers);
  10. // Using headSet() with default boolean value
  11. System.out.println("Using headSet without boolean value: " + numbers.headSet(5));
  12. // Using headSet() with specified boolean value
  13. System.out.println("Using headSet with boolean value: " + numbers.headSet(5, true));
  14. }
  15. }
Salida
TreeSet: [2, 4, 5, 6]
Usando headSet sin valor booleano: [2, 4]
Usando headSet con valor booleano: [2, 4, 5]

tailSet (elemento, valor booleano)

El tailSet()método devuelve todos los elementos de un conjunto de árbol después del elemento especificado (que se pasa como parámetro), incluido el elemento especificado .
El parámetro booleanValue es opcional. Su valor predeterminado es true.
Si falsese pasa como un valor booleano , el método devuelve todos los elementos después del elemento especificado sin incluir el elemento especificado .
Por ejemplo,
  1. import java.util.TreeSet;
  2. class Main {
  3. public static void main(String[] args) {
  4. TreeSet<Integer> numbers = new TreeSet<>();
  5. numbers.add(2);
  6. numbers.add(5);
  7. numbers.add(4);
  8. numbers.add(6);
  9. System.out.println("TreeSet: " + numbers);
  10. // Using tailSet() with default boolean value
  11. System.out.println("Using tailSet without boolean value: " + numbers.tailSet(4));
  12. // Using tailSet() with specified boolean value
  13. System.out.println("Using tailSet with boolean value: " + numbers.tailSet(4, false));
  14. }
  15. }
Salida
TreeSet: [2, 4, 5, 6]
Usando tailSet sin valor booleano: [4, 5, 6]
Usando tailSet con valor booleano: [5, 6]

subSet (e1, bv1, e2, bv2)

El subSet()método devuelve todos los elementos entre e1 y e2, incluido e1 .
El bv1 y el bv2 son parámetros opcionales. El valor predeterminado de bv1 es true, y el valor predeterminado de bv2 es false.
Si falsese pasa como bv1 , el método devuelve todos los elementos entre e1 y e2 sin incluirlos e1.
Si truese pasa como bv2 , el método devuelve todos los elementos entre e1 y e2 , incluido e1 .
Por ejemplo,
  1. import java.util.TreeSet;
  2. class Main {
  3. public static void main(String[] args) {
  4. TreeSet<Integer> numbers = new TreeSet<>();
  5. numbers.add(2);
  6. numbers.add(5);
  7. numbers.add(4);
  8. numbers.add(6);
  9. System.out.println("TreeSet: " + numbers);
  10. // Using subSet() with default boolean value
  11. System.out.println("Using subSet without boolean value: " + numbers.subSet(4, 6));
  12. // Using subSet() with specified boolean value
  13. System.out.println("Using subSet with boolean value: " + numbers.subSet(4, false, 6, true));
  14. }
  15. }
Salida
TreeSet: [2, 4, 5, 6]
Usando subSet sin valor booleano: [4, 5]
Usando subSet con valor booleano: [5, 6]

Establecer operaciones

Los métodos de la TreeSetclase también se pueden usar para realizar varias operaciones de conjuntos.

Unión de conjuntos

Para realizar la unión entre dos conjuntos, utilizamos el addAll()método. Por ejemplo,
  1. import java.util.TreeSet;;
  2. class Main {
  3. public static void main(String[] args) {
  4. TreeSet<Integer> evenNumbers = new TreeSet<>();
  5. evenNumbers.add(2);
  6. evenNumbers.add(4);
  7. System.out.println("TreeSet1: " + evenNumbers);
  8. TreeSet<Integer> numbers = new TreeSet<>();
  9. numbers.add(1);
  10. numbers.add(2);
  11. numbers.add(3);
  12. System.out.println("TreeSet2: " + numbers);
  13. // Union of two sets
  14. numbers.addAll(evenNumbers);
  15. System.out.println("Union is: " + numbers);
  16. }
  17. }
Salida
TreeSet1: [2, 4]
TreeSet2: [1, 2, 3]
La unión es: [1, 2, 3, 4]

Intersección de conjuntos

Para realizar la intersección entre dos conjuntos, utilizamos el retainAll()método. Por ejemplo,
  1. import java.util.TreeSet;;
  2. class Main {
  3. public static void main(String[] args) {
  4. TreeSet<Integer> evenNumbers = new TreeSet<>();
  5. evenNumbers.add(2);
  6. evenNumbers.add(4);
  7. System.out.println("TreeSet1: " + evenNumbers);
  8. TreeSet<Integer> numbers = new TreeSet<>();
  9. numbers.add(1);
  10. numbers.add(2);
  11. numbers.add(3);
  12. System.out.println("TreeSet2: " + numbers);
  13. // Intersection of two sets
  14. numbers.retainAll(evenNumbers);
  15. System.out.println("Intersection is: " + numbers);
  16. }
  17. }
Salida
TreeSet1: [2, 4]
TreeSet2: [1, 2, 3]
La intersección es: [2]

Diferencia de conjuntos

Para calcular la diferencia entre los dos conjuntos, podemos usar el removeAll()método. Por ejemplo,
  1. import java.util.TreeSet;;
  2. class Main {
  3. public static void main(String[] args) {
  4. TreeSet<Integer> evenNumbers = new TreeSet<>();
  5. evenNumbers.add(2);
  6. evenNumbers.add(4);
  7. System.out.println("TreeSet1: " + evenNumbers);
  8. TreeSet<Integer> numbers = new TreeSet<>();
  9. numbers.add(1);
  10. numbers.add(2);
  11. numbers.add(3);
  12. numbers.add(4);
  13. System.out.println("TreeSet2: " + numbers);
  14. // Difference between two sets
  15. numbers.removeAll(evenNumbers);
  16. System.out.println("Difference is: " + numbers);
  17. }
  18. }
Salida
TreeSet1: [2, 4]
TreeSet2: [1, 2, 3, 4]
La diferencia es: [1, 3]

Subconjunto de un conjunto

Para verificar si un conjunto es un subconjunto de otro conjunto o no, utilizamos el containsAll()método. Por ejemplo,
  1. import java.util.TreeSet;
  2. class Main {
  3. public static void main(String[] args) {
  4. TreeSet<Integer> numbers = new TreeSet<>();
  5. numbers.add(1);
  6. numbers.add(2);
  7. numbers.add(3);
  8. numbers.add(4);
  9. System.out.println("TreeSet1: " + numbers);
  10. TreeSet<Integer> primeNumbers = new TreeSet<>();
  11. primeNumbers.add(2);
  12. primeNumbers.add(3);
  13. System.out.println("TreeSet2: " + primeNumbers);
  14. // Check if primeNumbers is subset of numbers
  15. boolean result = numbers.containsAll(primeNumbers);
  16. System.out.println("Is TreeSet2 subset of TreeSet1? " + result);
  17. }
  18. }
Salida
TreeSet1: [1, 2,, 3, 4]
TreeSet2: [2, 3]
¿TreeSet2 es un subconjunto de TreeSet1? Cierto

Otros métodos de TreeSet

MétodoDescripción
clone()Crea una copia del TreeSet
contains()Busca en TreeSet el elemento especificado y devuelve un resultado booleano.
isEmpty()Comprueba si TreeSetestá vacío
size()Devuelve el tamaño de TreeSet
clear()Elimina todos los elementos del TreeSet
Para obtener más información, visite la documentación oficial de Java TreeSet .

TreeSet Vs. HashSet

Tanto el TreeSetcomo el HashSetimplementan la Setinterfaz. Sin embargo, existen algunas diferencias entre ellos.
  • A diferencia HashSet, los elementos en TreeSetse almacenan en algún orden. Es porque también TreeSetimplementa la SortedSetinterfaz.
  • TreeSetProporciona algunos métodos para facilitar la navegación. Por ejemplo, first()last()headSet(), tailSet(), etc. Es porque TreeSettambién implementa la NavigableSetinterfaz.
  • HashSetes más rápido que TreeSetpara operaciones básicas como agregar, eliminar, contiene y tamaño.

Comparador TreeSet

En todos los ejemplos anteriores, los elementos del conjunto de árboles se ordenan naturalmente. Sin embargo, también podemos personalizar el orden de los elementos.
Para esto, necesitamos crear nuestra propia clase de comparación basada en qué elementos de un conjunto de árbol están ordenados. Por ejemplo,
  1. import java.util.TreeSet;
  2. import java.util.Comparator;
  3. class Main {
  4. public static void main(String[] args) {
  5. // Creating a tree set with customized comparator
  6. TreeSet<String> animals = new TreeSet<>(new CustomComparator());
  7. animals.add("Dog");
  8. animals.add("Zebra");
  9. animals.add("Cat");
  10. animals.add("Horse");
  11. System.out.println("TreeSet: " + animals);
  12. }
  13. // Creating a comparator class
  14. public static class CustomComparator implements Comparator<String> {
  15. @Override
  16. public int compare(String animal1, String animal2) {
  17. int value = animal1.compareTo(animal2);
  18. // elements are sorted in reverse order
  19. if (value > 0) {
  20. return -1;
  21. }
  22. else if (value < 0) {
  23. return 1;
  24. }
  25. else {
  26. return 0;
  27. }
  28. }
  29. }
  30. }
Salida
TreeSet: [cebra, caballo, perro, gato]
En el ejemplo anterior, hemos creado un conjunto de árbol que pasa la clase CustomComparator como argumento.
La clase CustomComparator implementa la Comparatorinterfaz.
Luego anulamos el compare()método. El método ahora ordenará los elementos en orden inverso.
Para obtener más información sobre el comparador, visite Java Comparator .

Publicar un comentario

0 Comentarios