En este artículo, aprenderemos la diferencia entre HashSet vs LinkedHashSet y TreeSet y las similitudes entre LinkedHashSet y TreeSet. HashSet, LinkedHashSet y TreeSet implementan la interfaz Set. Así que hemos tratado de enumerar las diferencias y similitudes entre HashSet, LinkedHashSet y TreeSet en Java.
Diferencias entre HashSet, LinkedHashSet y TreeSet:
|
Características |
HashSet |
LinkedHashSet |
ÁrbolConjunto |
|---|---|---|---|
|
Trabajo interno |
HashSet usa internamente HashMap para almacenar objetos |
LinkedHashSet usa LinkedHashMap internamente para almacenar objetos |
TreeSet usa TreeMap internamente para almacenar objetos |
|
Cuándo usar |
Si no desea mantener el orden de inserción pero desea almacenar objetos únicos |
Si desea mantener el orden de inserción de los elementos, puede usar LinkedHashSet |
Si desea ordenar los elementos de acuerdo con algún comparador, use TreeSet |
|
Ordenar |
HashSet no mantiene el orden de inserción |
LinkedHashSet mantiene el orden de inserción de los objetos |
Mientras que TreeSet ordena los elementos según el Comparador proporcionado. De forma predeterminada, los objetos se colocarán según su orden ascendente natural. |
|
Complejidad de las Operaciones |
HashSet brinda complejidad O (1) para insertar, eliminar y recuperar objetos |
LinkedHashSet proporciona el rendimiento de las operaciones de inserción, eliminación y recuperación en el orden O(1). |
Mientras que TreeSet ofrece el rendimiento del orden O(log(n)) para las operaciones de inserción, eliminación y recuperación. |
|
Actuación |
El rendimiento de HashSet es mejor en comparación con LinkedHashSet y TreeSet. |
El rendimiento de LinkedHashSet es más lento que el de TreeSet. Es casi similar a HashSet pero más lento porque LinkedHashSet mantiene internamente LinkedList para mantener el orden de inserción de los elementos. |
El rendimiento de TreeSet es mejor que LinkedHashSet excepto para las operaciones de inserción y eliminación porque tiene que ordenar los elementos después de cada operación de inserción y eliminación. |
|
Comparar |
HashSet usa los métodos equals() y hashCode() para comparar los objetos |
LinkedHashSet usa los métodos equals() y hashCode() para comparar sus objetos |
TreeSet usa los métodos compare() y compareTo() para comparar los objetos |
|
Elementos nulos |
HashSet permite solo un valor nulo. |
LinkedHashSet solo permite un valor nulo. |
TreeSet no permite valores nulos. Si inserta un valor nulo en TreeSet, lanzará NullPointerException. |
|
Sintaxis |
HashSet obj = nuevo HashSet(); |
LinkedHashSet obj = nuevo LinkedHashSet(); |
TreeSet obj = new TreeSet(); |
Diferencias entre HashSet, LinkedHashSet y TreeSet según el orden de inserción y el tiempo empleado:
Java
// Java program to demonstrate difference between
// HashSet, LinkedHashSet and TreeSet according
// to insertion order and insertion time
import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;
class GFG1 {
// Function show insertion order of
// LinkedHashSet, TreeSet and HashSet
private static void insertionOrder()
{
LinkedHashSet<String> geekLinkSet
= new LinkedHashSet<>();
TreeSet<String> geekTreeSet = new TreeSet<>();
HashSet<String> geekHashSet = new HashSet<String>();
// Add three object in
// LinkedHashSet and TreeSet
for (String str : Arrays.asList("Geek2", "Geek1",
"Geek3", "Geek1")) {
geekLinkSet.add(str);
geekTreeSet.add(str);
geekHashSet.add(str);
}
// should be sorted order HashSet
// stores element in sorted order
System.out.println("Insertion Order"
+ " of objects in HashSet :"
+ geekHashSet);
// insertion order or elements LinkedHashSet
// storeds elements as insertion
System.out.println("Insertion Order of "
+ "objects in LinkedHashSet :"
+ geekLinkSet);
// should be sorted order TreeSet
// stores element in sorted order
System.out.println("Insertion Order of"
+ " objects in TreeSet :"
+ geekTreeSet);
}
// Function calculate insertion time of
// 1000 objects of LinkedHashSet,
// TreeSet and HashSet
private static void insertionTime()
{
// HashSet performance Test
// inserting 1000 elements
HashSet<Integer> numbersHS = new HashSet<>();
long startTime = System.nanoTime();
for (int i = 0; i < 1000; i++) {
numbersHS.add(i);
}
long endTime = System.nanoTime();
System.out.println("Total time to insert"
+ " 1000 elements in"
+ " HashSet in nanoseconds: "
+ (endTime - startTime));
// LinkedHashSet performance Test
// inserting 1000 elements
LinkedHashSet<Integer> numbersLLS
= new LinkedHashSet<>();
startTime = System.nanoTime();
for (int i = 0; i < 1000; i++) {
numbersLLS.add(i);
}
endTime = System.nanoTime();
System.out.println("Total time to insert"
+ " 1000 elements in"
+ " LinkedHashSet nanoseconds: "
+ (endTime - startTime));
// TreeSet performance Test inserting 1000 objects
TreeSet<Integer> numbersTS = new TreeSet<>();
startTime = System.nanoTime();
for (int i = 0; i < 1000; i++) {
numbersTS.add(i);
}
endTime = System.nanoTime();
System.out.println("Total time to insert"
+ " 1000 elements in"
+ " TreeSet in nanoseconds: "
+ (endTime - startTime));
}
// Function calculate deletion time
// of 1000 objects LinkedHashSet,
// TreeSet and HashSet
// Deletion time always vary
private static void deletion()
{
// HashSet performance Test inserting
// and deletion 1000 elements
HashSet<Integer> deletionHS = new HashSet<>();
for (int i = 0; i < 1000; i++) {
deletionHS.add(i);
}
long startingTime = System.nanoTime();
for (int i = 0; i < 1000; i++) {
deletionHS.remove(i);
}
long endedTime = System.nanoTime();
System.out.println(
"Total time to Deletion "
+ "1000 elements in HashSet in nanoseconds: "
+ Math.abs(startingTime - endedTime));
// LinkedHashSet performance Test inserting
// and deletion 1000 elements
LinkedHashSet<Integer> deletionLLS
= new LinkedHashSet<>();
for (int i = 0; i < 1000; i++) {
deletionLLS.add(i);
}
startingTime = System.nanoTime();
for (int i = 0; i < 1000; i++) {
deletionLLS.remove(i);
}
endedTime = System.nanoTime();
System.out.println(
"Total time to Deletion 1000"
+ " elements in LinkedHashSet in nanoseconds: "
+ Math.abs(startingTime - endedTime));
// TreeSet performance Test inserting
// and deletion 1000 elements
TreeSet<Integer> deletionTS = new TreeSet<>();
for (int i = 0; i < 1000; i++) {
deletionTS.add(i);
}
startingTime = System.nanoTime();
for (int i = 0; i < 1000; i++) {
deletionTS.remove(i);
}
endedTime = System.nanoTime();
System.out.println(
"Total time to Deletion 1000"
+ " elements in TreeSet in nanoseconds: "
+ Math.abs(startingTime - endedTime));
}
public static void main(String args[])
{
insertionOrder();
insertionTime();
deletion();
}
}
Insertion Order of objects in HashSet :[Geek3, Geek2, Geek1] Insertion Order of objects in LinkedHashSet :[Geek2, Geek1, Geek3] Insertion Order of objects in TreeSet :[Geek1, Geek2, Geek3] Total time to insert 1000 elements in HashSet in nanoseconds: 791869 Total time to insert 1000 elements in LinkedHashSet nanoseconds: 882417 Total time to insert 1000 elements in TreeSet in nanoseconds: 11797657 Total time to Deletion 1000 elements in HashSet in nanoseconds: 834509 Total time to Deletion 1000 elements in LinkedHashSet in nanoseconds: 898922 Total time to Deletion 1000 elements in TreeSet in nanoseconds: 7437577
Similitudes entre HashSet, LinkedHashSet y TreeSet:
- Duplicados: HashSet, LinkedHashSet y TreeSet son implementos de la interfaz Set, por lo que no se les permite almacenar objetos duplicados.
- Seguro para subprocesos: si queremos usar HashSet, LinkedHashSet y TreeSet en un entorno de subprocesos múltiples, primero lo sincronizamos externamente porque tanto LinkedHashSet como TreeSet no son seguros para subprocesos.
- Los tres son clonables y serializables.
Cuándo usar HashSet, TreeSet y LinkedHashSet en Java:
- HashSet: si no desea mantener el orden de inserción pero desea almacenar objetos únicos.
- LinkedHashSet: si desea mantener el orden de inserción de los elementos, puede usar LinkedHashSet.
- TreeSet: si desea ordenar los elementos de acuerdo con algún comparador, use TreeSet.
Entonces, como ve el resultado del programa anterior de acuerdo con eso y de acuerdo con sus requisitos, puede elegir cualquiera de HashSet, TreeSet y LinkedHashSet.