Java LinkedHashSet

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

El LinkedHashSet La clase del marco de colecciones de Java proporciona funcionalidades tanto de la tabla hash como de la estructura de datos de la lista enlazada.

Implementa la interfaz Set.

Elementos de LinkedHashSet se almacenan en tablas hash similares a HashSet.

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

Crear un LinkedHashSet

Para crear un conjunto hash vinculado, debemos importar el java.util.LinkedHashSet paquete primero.

Una vez que importamos el paquete, así es como podemos crear conjuntos hash vinculados en Java.

// LinkedHashSet with 8 capacity and 0.75 load factor
LinkedHashSet<Integer> numbers = new LinkedHashSet<>(8, 0.75);

Aquí, hemos creado un conjunto hash vinculado llamado numbers .

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

capacidad - La capacidad de este conjunto hash es 8. Es decir, puede almacenar 8 elementos.
factor de carga - El factor de carga de este conjunto hash es 0,6. Esto significa que, cada vez que nuestra tabla hash se llena en un 60 %, los elementos se mueven a una nueva tabla hash del doble del tamaño de la tabla hash original.

Capacidad predeterminada y factor de carga

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

// LinkedHashSet with default capacity and load factor
LinkedHashSet<Integer> numbers1 = new LinkedHashSet<>();

Por defecto,

la capacidad del conjunto hash vinculado será 16
el factor de carga será 0,75

Crear LinkedHashSet a partir de otras colecciones

Así es como podemos crear un conjunto hash vinculado que contenga todos los elementos de otras colecciones.

import java.util.LinkedHashSet;
import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        // Creating an arrayList of even numbers
        ArrayList<Integer> evenNumbers = new ArrayList<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("ArrayList: " + evenNumbers);

        // Creating a LinkedHashSet from an ArrayList
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>(evenNumbers);
        System.out.println("LinkedHashSet: " + numbers);
    }
}

Salida

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

Métodos de LinkedHashSet

El LinkedHashSet La clase proporciona métodos que nos permiten realizar varias operaciones en el conjunto hash vinculado.

Insertar elementos en LinkedHashSet

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

Por ejemplo,

import java.util.LinkedHashSet;

class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> evenNumber = new LinkedHashSet<>();

        // Using add() method
        evenNumber.add(2);
        evenNumber.add(4);
        evenNumber.add(6);
        System.out.println("LinkedHashSet: " + evenNumber);

        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        
        // Using addAll() method
        numbers.addAll(evenNumber);
        numbers.add(5);
        System.out.println("New LinkedHashSet: " + numbers);
    }
}

Salida

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

Acceso a elementos de LinkedHashSet

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

import java.util.LinkedHashSet;
import java.util.Iterator;

class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(6);
        System.out.println("LinkedHashSet: " + numbers);

        // Calling the iterator() method
        Iterator<Integer> iterate = numbers.iterator();

        System.out.print("LinkedHashSet using Iterator: ");

        // Accessing elements
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

Salida

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

Nota :

hasNext() devuelve true si hay un elemento siguiente en el conjunto hash vinculado
next() devuelve el siguiente elemento en el conjunto hash vinculado

Eliminar elementos de HashSet

remove() - elimina el elemento especificado del conjunto hash vinculado
removeAll() - elimina todos los elementos del conjunto hash vinculado

Por ejemplo,

import java.util.LinkedHashSet;

class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(6);
        System.out.println("LinkedHashSet: " + numbers);

        // Using the remove() method
        boolean value1 = numbers.remove(5);
        System.out.println("Is 5 removed? " + value1);

        boolean value2 = numbers.removeAll(numbers);
        System.out.println("Are all elements removed? " + value2);
    }
}

Salida

LinkedHashSet: [2, 5, 6]
Is 5 removed? true
Are all elements removed? true

Establecer operaciones

Los diversos métodos del LinkedHashSet La clase también se puede usar para realizar varias operaciones de conjuntos.

Unión de Conjuntos

Dos realizan la unión entre dos conjuntos, podemos usar el addAll() método. Por ejemplo,

import java.util.LinkedHashSet;

class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> evenNumbers = new LinkedHashSet<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("LinkedHashSet1: " + evenNumbers);

        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        numbers.add(1);
        numbers.add(3);
        System.out.println("LinkedHashSet2: " + numbers);

        // Union of two set
        numbers.addAll(evenNumbers);
        System.out.println("Union is: " + numbers);
    }
}

Salida

LinkedHashSet1: [2, 4]
LinkedHashSet2: [1, 3]
Union is: [1, 3, 2, 4]

Intersección de Conjuntos

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

import java.util.LinkedHashSet;

class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        System.out.println("LinkedHashSet1: " + primeNumbers);

        LinkedHashSet<Integer> evenNumbers = new LinkedHashSet<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("LinkedHashSet2: " + evenNumbers);

        // Intersection of two sets
        evenNumbers.retainAll(primeNumbers);
        System.out.println("Intersection is: " + evenNumbers);
    }
}

Salida

LinkedHashSet1: [2, 3]
LinkedHashSet2: [2, 4]
Intersection is: [2]

Diferencia de Conjuntos

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

import java.util.LinkedHashSet;

class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        primeNumbers.add(5);
        System.out.println("LinkedHashSet1: " + primeNumbers);

        LinkedHashSet<Integer> oddNumbers = new LinkedHashSet<>();
        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);
        System.out.println("LinkedHashSet2: " + oddNumbers);

        // Difference between LinkedHashSet1 and LinkedHashSet2
        primeNumbers.removeAll(oddNumbers);
        System.out.println("Difference : " + primeNumbers);
    }
}

Salida

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

Subconjunto

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

import java.util.LinkedHashSet;

class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        System.out.println("LinkedHashSet1: " + numbers);

        LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        System.out.println("LinkedHashSet2: " + primeNumbers);

        // Check if primeNumbers is a subset of numbers
        boolean result = numbers.containsAll(primeNumbers);
        System.out.println("Is LinkedHashSet2 is subset of LinkedHashSet1? " + result);
    }
}

Salida

LinkedHashSet1: [1, 2, 3, 4]
LinkedHashSet2: [2, 3]
Is LinkedHashSet2 is a subset of LinkedHashSet1? true

Otros métodos de LinkedHashSet

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

Para obtener más información sobre LinkedHashSet métodos, visite Java LinkedHashSet (documentación oficial de Java).

LinkedHashSet vs. HashSet

Ambos LinkedHashSet y HashSet implementa el Set interfaz. 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.
El LinkedHashSet la clase requiere más almacenamiento que HashSet . Esto se debe a que LinkedHashSet mantiene listas enlazadas internamente.
El rendimiento de LinkedHashSet es más lento que HashSet . Es por las listas enlazadas presentes en LinkedHashSet .

LinkedHashSet vs. Conjunto de árboles

Estas son las principales diferencias entre LinkedHashSet y TreeSet :

El TreeSet clase implementa el SortedSet interfaz. Es por eso que se ordenan los elementos en un conjunto de árboles. Sin embargo, el LinkedHashSet class solo mantiene el orden de inserción de sus elementos.
Un TreeSet suele ser más lento que un LinkedHashSet . Es porque cada vez que se agrega un elemento a un TreeSet , tiene que realizar la operación de clasificación.
LinkedHashSet permite la inserción de valores nulos. Sin embargo, no podemos insertar un valor nulo en TreeSet .

Java EnumSet Interfaz Java SortedSet

Java