Dominando Java LinkedHashSet: Características, Métodos y Ejemplos Prácticos

Java LinkedHashSet

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

La clase LinkedHashSet del framework de colecciones de Java proporciona funcionalidades tanto de hashtable como de estructura de datos lista enlazada.

Implementa la interfaz Set.

Los elementos de LinkedHashSet se almacenan en tablas hash similares a HashSet.

Sin embargo, los linked hash sets mantienen una lista doblemente enlazada internamente para todos sus elementos. La lista enlazada define el orden en que los elementos se insertan en las tablas hash.

Crear un LinkedHashSet

Para crear un linked hash set, primero debemos importar el paquete java.util.LinkedHashSet.

Una vez importado el paquete, así es como podemos crear linked hash sets en Java.

// LinkedHashSet con capacidad 8 y factor de carga 0.75
LinkedHashSet<Integer> numeros = new LinkedHashSet<>(8, 0.75);

Aquí, hemos creado un linked hash set llamado numeros.

Observa la parte new LinkedHashSet<>(8, 0.75). Aquí, el primer parámetro es capacidad y el segundo es factorDeCarga.

capacidad - La capacidad de este hash set es 8. Significa que puede almacenar 8 elementos.
factorDeCarga - El factor de carga de este hash set es 0.75. Esto significa que siempre que nuestra tabla hash se llene al 75%, los elementos se mueven a una nueva tabla hash del doble del tamaño de la original.

Capacidad y factor de carga por defecto

Es posible crear un linked hash set sin definir su capacidad y factor de carga. Por ejemplo,

// LinkedHashSet con capacidad y factor de carga por defecto
LinkedHashSet<Integer> numeros1 = new LinkedHashSet<>();

Por defecto,

la capacidad del linked hash set será 16
el factor de carga será 0.75

Creando LinkedHashSet desde Otras Colecciones

Aquí está cómo podemos crear un linked hash set conteniendo todos los elementos de otras colecciones.

import java.util.LinkedHashSet;
import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        // Creando un arrayList de números pares
        ArrayList<Integer> numerosPares = new ArrayList<>();
        numerosPares.add(2);
        numerosPares.add(4);
        System.out.println("ArrayList: " + numerosPares);
        // Creando un LinkedHashSet desde un ArrayList
        LinkedHashSet<Integer> numeros = new LinkedHashSet<>(numerosPares);
        System.out.println("LinkedHashSet: " + numeros);
    }
}

Salida

ArrayList: [2, 4] LinkedHashSet: [2, 4]

Métodos de LinkedHashSet

La clase LinkedHashSet proporciona métodos que nos permiten realizar varias operaciones en el linked hash set.

Insertar Elementos en LinkedHashSet

add() - inserta el elemento especificado en el linked hash set
addAll() - inserta todos los elementos de la colección especificada en el linked hash set

Por ejemplo,

import java.util.LinkedHashSet;
class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numerosPares = new LinkedHashSet<>();
        // Usando add()
        numerosPares.add(2);
        numerosPares.add(4);
        numerosPares.add(6);
        System.out.println("LinkedHashSet: " + numerosPares);
        LinkedHashSet<Integer> numeros = new LinkedHashSet<>();
        // Usando addAll()
        numeros.addAll(numerosPares);
        numeros.add(5);
        System.out.println("Nuevo LinkedHashSet: " + numeros);
    }
}

Salida

LinkedHashSet: [2, 4, 6] Nuevo LinkedHashSet: [2, 4, 6, 5]

Acceder a Elementos de LinkedHashSet

Para acceder a los elementos de un linked hash set, podemos usar el método iterator(). Para usar este método, debemos importar el paquete java.util.Iterator. Por ejemplo,

import java.util.LinkedHashSet;
import java.util.Iterator;
class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numeros = new LinkedHashSet<>();
        numeros.add(2);
        numeros.add(5);
        numeros.add(6);
        System.out.println("LinkedHashSet: " + numeros);
        // Llamando al método iterator()
        Iterator<Integer> iterar = numeros.iterator();
        System.out.print("LinkedHashSet usando Iterator: ");
        // Accediendo a elementos
        while(iterar.hasNext()) {
            System.out.print(iterar.next());
            System.out.print(", ");
        }
    }
}

Salida

LinkedHashSet: [2, 5, 6] LinkedHashSet usando Iterator: 2, 5, 6,

Nota:

hasNext() devuelve true si hay un siguiente elemento en el linked hash set
next() devuelve el siguiente elemento en el linked hash set

Eliminar Elementos de HashSet

remove() - elimina el elemento especificado del linked hash set
removeAll() - elimina todos los elementos del linked hash set

Por ejemplo,

import java.util.LinkedHashSet;
class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numeros = new LinkedHashSet<>();
        numeros.add(2);
        numeros.add(5);
        numeros.add(6);
        System.out.println("LinkedHashSet: " + numeros);
        // Usando remove()
        boolean valor1 = numeros.remove(5);
        System.out.println("¿Se eliminó 5? " + valor1);
        boolean valor2 = numeros.removeAll(numeros);
        System.out.println("¿Se eliminaron todos los elementos? " + valor2);
    }
}

Salida

LinkedHashSet: [2, 5, 6] ¿Se eliminó 5? true ¿Se eliminaron todos los elementos? true

Operaciones de Conjunto

Los varios métodos de la clase LinkedHashSet también pueden usarse para realizar operaciones de conjunto.

Unión de Conjuntos

Para realizar la unión entre dos sets, podemos usar el método addAll(). Por ejemplo,

import java.util.LinkedHashSet;
class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numerosPares = new LinkedHashSet<>();
        numerosPares.add(2);
        numerosPares.add(4);
        System.out.println("LinkedHashSet1: " + numerosPares);
        LinkedHashSet<Integer> numeros = new LinkedHashSet<>();
        numeros.add(1);
        numeros.add(3);
        System.out.println("LinkedHashSet2: " + numeros);
        // Unión de dos sets
        numeros.addAll(numerosPares);
        System.out.println("Unión es: " + numeros);
    }
}

Salida

LinkedHashSet1: [2, 4] LinkedHashSet2: [1, 3] Unión es: [1, 3, 2, 4]

Intersección de Conjuntos

Para realizar la intersección entre dos sets, podemos usar el método retainAll(). Por ejemplo

import java.util.LinkedHashSet;
class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numerosPrimos = new LinkedHashSet<>();
        numerosPrimos.add(2);
        numerosPrimos.add(3);
        System.out.println("LinkedHashSet1: " + numerosPrimos);
        LinkedHashSet<Integer> numerosPares = new LinkedHashSet<>();
        numerosPares.add(2);
        numerosPares.add(4);
        System.out.println("LinkedHashSet2: " + numerosPares);
        // Intersección de dos sets
        numerosPares.retainAll(numerosPrimos);
        System.out.println("Intersección es: " + numerosPares);
    }
}

Salida

LinkedHashSet1: [2, 3] LinkedHashSet2: [2, 4] Intersección es: [2]

Diferencia de Conjuntos

Para calcular la diferencia entre dos sets, podemos usar el método removeAll(). Por ejemplo,

import java.util.LinkedHashSet;
class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numerosPrimos = new LinkedHashSet<>();
        numerosPrimos.add(2);
        numerosPrimos.add(3);
        numerosPrimos.add(5);
        System.out.println("LinkedHashSet1: " + numerosPrimos);
        LinkedHashSet<Integer> numerosImpares = new LinkedHashSet<>();
        numerosImpares.add(1);
        numerosImpares.add(3);
        numerosImpares.add(5);
        System.out.println("LinkedHashSet2: " + numerosImpares);
        // Diferencia entre LinkedHashSet1 y LinkedHashSet2
        numerosPrimos.removeAll(numerosImpares);
        System.out.println("Diferencia: " + numerosPrimos);
    }
}

Salida

LinkedHashSet1: [2, 3, 5] LinkedHashSet2: [1, 3, 5] Diferencia: [2]

Subconjunto

Para verificar si un set es subconjunto de otro, podemos usar el método containsAll(). Por ejemplo,

import java.util.LinkedHashSet;
class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numeros = new LinkedHashSet<>();
        numeros.add(1);
        numeros.add(2);
        numeros.add(3);
        numeros.add(4);
        System.out.println("LinkedHashSet1: " + numeros);
        LinkedHashSet<Integer> numerosPrimos = new LinkedHashSet<>();
        numerosPrimos.add(2);
        numerosPrimos.add(3);
        System.out.println("LinkedHashSet2: " + numerosPrimos);
        // Verificar si numerosPrimos es subconjunto de numeros
        boolean resultado = numeros.containsAll(numerosPrimos);
        System.out.println("¿Es LinkedHashSet2 subconjunto de LinkedHashSet1? " + resultado);
    }
}

Salida

LinkedHashSet1: [1, 2, 3, 4] LinkedHashSet2: [2, 3] ¿Es LinkedHashSet2 subconjunto de LinkedHashSet1? true

Otros Métodos de LinkedHashSet

Método	Descripción
`clone()`	Crea una copia del `LinkedHashSet`
`contains()`	Busca en el `LinkedHashSet` el elemento especificado y devuelve resultado booleano
`isEmpty()`	Verifica si el `LinkedHashSet` está vacío
`size()`	Devuelve el tamaño del `LinkedHashSet`
`clear()`	Elimina todos los elementos del `LinkedHashSet`

Para aprender más sobre métodos de LinkedHashSet, visita Java LinkedHashSet (documentación oficial).

LinkedHashSet vs. HashSet

Tanto LinkedHashSet como HashSet implementan la interfaz Set. Sin embargo, existen algunas diferencias entre ellos.

LinkedHashSet mantiene una lista enlazada internamente. Debido a esto, mantiene el orden de inserción de sus elementos.
La clase LinkedHashSet requiere más almacenamiento que HashSet. Esto es porque LinkedHashSet mantiene listas enlazadas internamente.
El rendimiento de LinkedHashSet es más lento que HashSet. Es debido a las listas enlazadas presentes en LinkedHashSet.

LinkedHashSet vs. TreeSet

Aquí están las mayores diferencias entre LinkedHashSet y TreeSet:

La clase TreeSet implementa la interfaz SortedSet. Por eso los elementos en un tree set están ordenados. Sin embargo, la clase LinkedHashSet solo mantiene el orden de inserción de sus elementos.
Un TreeSet es usualmente más lento que un LinkedHashSet. Es porque cada vez que se añade un elemento a un TreeSet, tiene que realizar la operación de ordenamiento.
LinkedHashSet permite la inserción de valores null. Sin embargo, no podemos insertar un valor null en TreeSet.

Java EnumSet: Creación, Operaciones y Consejos de Rendimiento Dominando Java SortedSet: Guía Práctica de TreeSet y Sus Métodos

Java