HashSet frente a TreeSet en Java

Cuando se trata de discutir las diferencias entre Set, lo primero que entra en juego es el orden de inserción y cómo se procesarán los elementos. HashSet en java es una clase que implementa la interfaz Set , respaldada por una tabla hash que en realidad es una instancia de HashMap . Esta clase permite el elemento nulo. La clase también ofrece un rendimiento de tiempo constante para las operaciones básicas como agregar, eliminar, contener y dimensionar, suponiendo que la función hash dispersa los elementos correctamente entre los cubos, mientras que TreeSet es una implementación de la interfaz SortedSet que, como sugiere el nombre, usa el árbol para el almacenamiento. propósitos donde aquí el ordenamiento de los elementos es mantenido por un conjunto usando su ordenamiento natural sea o no un explícitose proporciona comparador .

 

1. Rapidez e implementación interna 

Para operaciones como buscar, insertar y eliminar, HashSet toma un tiempo constante para estas operaciones en promedio. HashSet es más rápido que TreeSet. HashSet se implementa mediante una tabla hash . TreeSet toma O (Log n) para buscar, insertar y eliminar, que es más alto que HashSet. Pero TreeSet mantiene los datos ordenados. Además, admite operaciones como más alto() (devuelve el elemento menos alto), piso(), techo(), etc. Estas operaciones también son O (Iniciar sesión) en TreeSet y no se admiten en HashSet. TreeSet se implementa mediante un árbol de búsqueda binaria autoequilibrado (árbol rojo-negro ). TreeSet está respaldado por TreeMap en Java.

2. Ordenar 

Los elementos en HashSet no están ordenados. TreeSet mantiene los objetos en orden ordenado definido por el método Comparable o Comparator en Java. Los elementos de TreeSet se ordenan en orden ascendente de forma predeterminada. Ofrece varios métodos para manejar el conjunto ordenado como first(), last(), headSet(), tailSet(), etc.

3. Objeto nulo 

HashSet permite objeto nulo. TreeSet no permite objetos nulos y lanza NullPointerException, por qué, porque TreeSet usa el método compareTo() para comparar claves y compareTo() lanzará java.lang.NullPointerException.

4. Comparación 

HashSet usa el método equals() para comparar dos objetos en Set y para detectar duplicados. TreeSet usa el método compareTo() para el mismo propósito. Si equals() y compareTo() no son consistentes, es decir, para dos objetos iguales, equals debe devolver verdadero mientras que compareTo() debe devolver cero, entonces romperá el contrato de la interfaz Set y permitirá duplicados en implementaciones Set como TreeSet

Nota: si desea un conjunto ordenado, es mejor agregar elementos a HashSet y luego convertirlo en TreeSet en lugar de crear un TreeSet y agregarle elementos.

Geek después de pasar por sus diferencias ahora debe preguntarse cuándo preferir TreeSet sobre HashSet .

1. Se requieren elementos únicos ordenados en lugar de elementos únicos. La lista ordenada dada por TreeSet siempre está en orden ascendente.
2. TreeSet tiene una localidad mayor que HashSet. Si dos entradas están cerca en el orden, entonces TreeSet las coloca una cerca de la otra en la estructura de datos y, por lo tanto, en la memoria, mientras que HashSet distribuye las entradas en toda la memoria, independientemente de las claves a las que estén asociadas.
3. TreeSet utiliza un algoritmo de árbol rojo-negro debajo para ordenar los elementos. Cuando se necesita realizar operaciones de lectura/escritura con frecuencia, TreeSet es una buena opción.
4. LinkedHashSet es otra estructura de datos que se encuentra entre estos dos. Proporciona complejidades de tiempo como HashSet y mantiene el orden de inserción (tenga en cuenta que este no es un orden ordenado, sino el orden en que se insertan los elementos).

Implementación: Aquí discutiremos ambos con 2 ejemplos para ambos. Comencemos con HashSet y más tarde nos detengamos en TreeSet. 

• Ejemplos de HashSet
• Ejemplos de TreeSet

Ejemplo 1:

// Java Program to Demonstrate Working of HashSet Class
 
// Importing required HashSet class from java.util package
import java.util.HashSet;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating a HashSet object of string type
        HashSet<String> hset = new HashSet<String>();
 
        // Adding elements to HashSet
        // using add() method
        hset.add("geeks");
        hset.add("for");
        hset.add("practice");
        hset.add("contribute");
 
        // Duplicate removed
        hset.add("geeks");
 
        // Printing HashSet elements using for each loop
 
        // Display message only
        System.out.println("HashSet contains: ");
 
        // Iterating over hashSet using for-each loop
        for (String temp : hset) {
 
            // Printing all elements inside above hashSet
            System.out.println(temp);
        }
    }
}

HashSet contains: 
practice
geeks
for
contribute

Ejemplo 2:

// Java Program to Illustrate Working of HashSet Class
// From another Collection
 
// Importing utility classes
import java.util.*;
 
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        ArrayList<String> ll = new ArrayList<String>();
 
        // Adding elements to ArrayList
        ll.add("Computer");
        ll.add("Science");
 
        // Creating HashSet object of string type
        HashSet<String> hs = new HashSet(ll);
        hs.add("Portal");
        hs.add("GFG");
 
        // Iterating via iterators
        Iterator<String> iter = hs.iterator();
 
        // Condition holds true till there is single element
        // in th List
        while (iter.hasNext()) {
 
            // Printing all elements inside objects
            System.out.println(iter.next());
        }
    }
}

Producción:

Ahora es el momento de implementar TreeSet para comprenderlo mejor a través de su implementación.

Ejemplo 1:

// Java program to demonstrate working of
// TreeSet Class
 
// Importing required classes
import java.util.TreeSet;
 
// Class
class TreeSetDemo {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Create an empty TreeSet
        TreeSet<String> tset = new TreeSet<String>();
 
        // Adding elements to HashSet
        // using add() method
        tset.add("geeks");
        tset.add("for");
        tset.add("practice");
        tset.add("contribute");
 
        // Duplicate elements being removed
        tset.add("geeks");
 
        // Displaying TreeSet elements
        System.out.println("TreeSet contains: ");
       
        for (String temp : tset) {
            System.out.println(temp);
        }
    }
}

TreeSet contains: 
contribute
for
geeks
practice

Ejemplo 2:

// Java Program to Illustrate Working of TreeSet
// From another Collection
 
// Importing utility classes
import java.util.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating list of string
        ArrayList<String> ll = new ArrayList<String>();
 
        // Adding elements to ArrayList
        // using add() method
        ll.add("Computer");
        ll.add("Science");
 
        // Creating TreeSet object of string type
        TreeSet<String> ts = new TreeSet(ll);
 
        // Adding elements to above TreeSet
        ts.add("Portal");
        ts.add("GFG");
 
        // Iterating via iterators
        Iterator<String> iter = ts.iterator();
 
        // Condition that holds true till
        // there is single element in th List
        while (iter.hasNext()) {
 
            // Printing all elements inside objects
            System.out.println(iter.next());
        }
    }
}

Producción: