Java TreeSet

En este tutorial, aprenderemos sobre la clase Java TreeSet y sus diversas operaciones y métodos con la ayuda de ejemplos.

Reú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 .

---

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.

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,

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]
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,

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

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,

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

Conjunto de árboles: [2, 5, 6]
¿Se han eliminado 5? cierto
¿Se eliminan todos los elementos? cierto

---

Métodos de Navegación

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,

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

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 element. Si el elemento pasado existe en un conjunto de árbol, devuelve el elementpasado 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]
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,

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]
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,

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]
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,

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]
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,

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]
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,

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]
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,

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]
La intersección es: [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]
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,

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]
¿TreeSet2 es un subconjunto de TreeSet1? Cierto

---

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 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,

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: [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 .