Java LinkedHashSet

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

Oferta por tiempo limitado: obtenga 10 imágenes gratuitas de Adobe Stock.ANUNCIOS A TRAVÉS DE CARBONO

La LinkedHashSetclase del marco de colecciones de Java proporciona funcionalidades tanto de la tabla hash como de la estructura de datos de la lista vinculada.

Implementa la interfaz Set .

Los elementos de LinkedHashSetse almacenan en tablas hash similares a HashSet .

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

---

Crear un conjunto LinkedHash

Para crear un conjunto de hash vinculado, java.util.LinkedHashSetprimero debemos importar el paquete.

Una vez que importamos el paquete, así es como podemos crear conjuntos de 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 de hash vinculado llamado números .

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

• capacidad : la capacidad de este conjunto de hash es 8. Es decir, puede almacenar 8 elementos.
• loadFactor : el factor de carga de este conjunto de 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 de 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 de hash vinculado será de 16
• el factor de carga será 0.75

---

Crear LinkedHashSet desde otras colecciones

Aquí es cómo podemos crear un conjunto de 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

La LinkedHashSetclase proporciona métodos que nos permiten realizar varias operaciones en el conjunto de hash vinculado.

---

Insertar elementos en LinkedHashSet

• add() - inserta el elemento especificado en el conjunto de hash vinculado
• addAll() - inserta todos los elementos de la colección especificada en el conjunto de 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]
Nuevo LinkedHashSet: [2, 4, 5, 6]

---

Acceder a elementos LinkedHashSet

Para acceder a los elementos de un conjunto de hash vinculado, podemos usar el iterator()método Para utilizar este método, debemos importar el java.util.Iteratorpaquete. 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 usando Iterator: 2, 5, 6,

Nota :

• hasNext()devuelve truesi hay un siguiente elemento en el conjunto de hash vinculado
• next() devuelve el siguiente elemento en el conjunto de hash vinculado

---

Eliminar elementos de HashSet

• remove() - elimina el elemento especificado del conjunto de hash vinculado
• removeAll() - elimina todos los elementos del conjunto de 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]
¿Se han eliminado 5? Cierto
¿Se eliminan todos los elementos? Cierto

---

Establecer operaciones

Los diversos métodos de la LinkedHashSetclase también se pueden utilizar 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]
La unión es: [1, 2, 3, 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]
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.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]
Diferencia: [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]
¿LinkedHashSet2 es un subconjunto de LinkedHashSet1? Cierto

---

Otros métodos de LinkedHashSet

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

Para obtener más información sobre los LinkedHashSetmétodos, visite Java LinkedHashSet .

---

LinkedHashSet Vs. HashSet

Ambos LinkedHashSete HashSetimplementa la Setinterfaz. Sin embargo, existen algunas diferencias entre ellos.

• LinkedHashSetmantiene una lista vinculada internamente. Debido a esto, mantiene el orden de inserción de sus elementos.
• La LinkedHashSetclase requiere más almacenamiento que HashSet. Esto se debe a que LinkedHashSetmantiene listas vinculadas internamente.
• El rendimiento de LinkedHashSetes más lento que HashSet. Se debe a las listas vinculadas presentes en LinkedHashSet.

---

---

LinkedHashSet Vs. TreeSet

Estas son las principales diferencias entre LinkedHashSety TreeSet:

• La TreeSetclase implementa la SortedSetinterfaz. Es por eso que los elementos en un conjunto de árbol están ordenados. Sin embargo, la LinkedHashSetclase solo mantiene el orden de inserción de sus elementos.
• A TreeSetsuele ser más lento que a LinkedHashSet. Esto se debe a que cada vez que se agrega un elemento a un elemento TreeSet, debe realizar la operación de clasificación.
• LinkedHashSetpermite la inserción de valores nulos. Sin embargo, no podemos insertar un valor nulo en TreeSet.