LinkedHashSet en Java con ejemplos

LinkedHashSet es una versión ordenada de HashSet que mantiene una lista doblemente vinculada en todos los elementos. Cuando se necesita mantener el orden de iteración, se utiliza esta clase. Al iterar a través de un HashSet , el orden es impredecible, mientras que un LinkedHashSet nos permite iterar a través de los elementos en el orden en que se insertaron. Al recorrer LinkedHashSet con un iterador, los elementos se devolverán en el orden en que se insertaron.

La jerarquía de LinkedHashSet es la siguiente:

Parámetros: el tipo de elementos que mantiene este conjunto

All Implemented Interfaces are as listed below:
Serializable
Cloneable,
Iterable<E>
Collection<E>
Set<E>

Sintaxis: Declaración 

public class LinkedHashSet<E> extends HashSet<E> implements Set<E>, Cloneable, Serializable

• Contiene elementos únicos solo como HashSet. Extiende la clase HashSet e implementa la interfaz Set.
• Mantiene el orden de inserción.

Constructores de la clase LinkedHashSet

1. LinkedHashSet(): este constructor se usa para crear un HashSet predeterminado

LinkedHashSet<E> hs = new LinkedHashSet<E>();

2. LinkedHashSet (Colección C): se utiliza para inicializar el HashSet con los elementos de la colección C.

LinkedHashSet<E> hs = new LinkedHashSet<E>(Collection c);

3. LinkedHashSet(int size): Usado para inicializar el tamaño del LinkedHashSet con el entero mencionado en el parámetro.

LinkedHashSet<E> hs = new LinkedHashSet<E>(int size);

4. LinkedHashSet(int capacity, float fillRatio): se puede utilizar para inicializar tanto la capacidad como la tasa de llenado, también llamada capacidad de carga del LinkedHashSet con los argumentos mencionados en el parámetro. Cuando el número de elementos supera la capacidad del conjunto hash, se multiplica por el índice de relleno, lo que amplía la capacidad del LinkedHashSet.

LinkedHashSet<E> hs = new LinkedHashSet<E>(int capacity, int fillRatio);

Ejemplo:

// Java Program to Illustrate LinkedHashSet
 
// Importing required classes
import java.util.LinkedHashSet;
 
// Main class
// LinkedHashSetExample
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an empty LinkedHashSet of string type
        LinkedHashSet<String> linkedset
            = new LinkedHashSet<String>();
 
        // Adding element to LinkedHashSet
        // using add() method
        linkedset.add("A");
        linkedset.add("B");
        linkedset.add("C");
        linkedset.add("D");
 
        // Note: This will not add new element
        // as A already exists
        linkedset.add("A");
        linkedset.add("E");
 
        // Getting size of LinkedHashSet
        // using size() method
        System.out.println("Size of LinkedHashSet = "
                           + linkedset.size());
 
        System.out.println("Original LinkedHashSet:"
                           + linkedset);
 
        // Removing existing entry from above Set
        // using remove() method
        System.out.println("Removing D from LinkedHashSet: "
                           + linkedset.remove("D"));
 
        // Removing existing entry from above Set
        // that does not exist in Set
        System.out.println(
            "Trying to Remove Z which is not "
            + "present: " + linkedset.remove("Z"));
 
        // Checking for element whether it is present inside
        // Set or not using contains() method
        System.out.println("Checking if A is present="
                           + linkedset.contains("A"));
 
        // Noew lastly printing the updated LinkedHashMap
        System.out.println("Updated LinkedHashSet: "
                           + linkedset);
    }
}

Size of LinkedHashSet = 5
Original LinkedHashSet:[A, B, C, D, E]
Removing D from LinkedHashSet: true
Trying to Remove Z which is not present: false
Checking if A is present=true
Updated LinkedHashSet: [A, B, C, E]

Realización de varias operaciones en la clase LinkedHashSet

Veamos cómo realizar algunas operaciones de uso frecuente en LinkedHashSet.

Operación 1: Adición de elementos

Para agregar un elemento al LinkedHashSet, podemos usar el método add() . Esto es diferente de HashSet porque en HashSet, el orden de inserción no se retiene pero se retiene en LinkedHashSet.

Ejemplo:

// Java Program to Add Elements to LinkedHashSet
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Main class
// AddingElementsToLinkedHashSet
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an empty LinkedHashSet
        LinkedHashSet<String> hs = new LinkedHashSet<String>();
 
        // Adding elements to above Set
        // using add() method
 
        // Note: Insertion order is maintained
        hs.add("Geek");
        hs.add("For");
        hs.add("Geeks");
 
        // Printing elements of Set
        System.out.println("LinkedHashSet : " + hs);
    }
}

LinkedHashSet : [Geek, For, Geeks]

Operación 2: Eliminación de elementos

Los valores se pueden eliminar de LinkedHashSet mediante el método remove() .

Ejemplo:

// Java program to Remove Elements from LinkedHashSet
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Main class
// RemoveElementsFromLinkedHashSet
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an empty LinekdhashSet of string type
        LinkedHashSet<String> hs
            = new LinkedHashSet<String>();
 
        // Adding elements to above Set
        // using add() method
        hs.add("Geek");
        hs.add("For");
        hs.add("Geeks");
        hs.add("A");
        hs.add("B");
        hs.add("Z");
 
        // Printing all above elements to the console
        System.out.println("Initial HashSet " + hs);
 
        // Removing the element from above Set
        hs.remove("B");
 
        // Again removing the element
        System.out.println("After removing element " + hs);
 
        // Returning false if the element is not present
        System.out.println(hs.remove("AC"));
    }
}

Initial HashSet [Geek, For, Geeks, A, B, Z]
After removing element [Geek, For, Geeks, A, Z]
false

Operación 3: Iterando a través de LinkedHashSet

Iterar a través de los elementos de LinkedHashSet utilizando el método iterator() . El más famoso es usar el bucle for mejorado.

Ejemplo:

// Java Program to Illustrate Iterating over LinkedHashSet
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Main class
// IteratingLinkedHashSet
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Instantiate an object of Set
        // Since LinkedHashSet implements Set
        // Set points to LinkedHashSet
        Set<String> hs = new LinkedHashSet<String>();
 
        // Adding elements to above Set
        // using add() method
        hs.add("Geek");
        hs.add("For");
        hs.add("Geeks");
        hs.add("A");
        hs.add("B");
        hs.add("Z");
 
        // Iterating though the LinkedHashSet
        // using iterators
        Iterator itr = hs.iterator();
 
        while (itr.hasNext())
            System.out.print(itr.next() + ", ");
 
        // New line
        System.out.println();
 
        // Using enhanced for loop for iteration
        for (String s : hs)
            System.out.print(s + ", ");
        System.out.println();
    }
}

Geek, For, Geeks, A, B, Z, 
Geek, For, Geeks, A, B, Z, 

 Métodos de LinkedHashSet

Aquí, E es el tipo de elemento almacenado.

Métodos declarados en la clase java.util.AbstractSet

Métodos declarados en la clase java.util.AbstractCollection

Métodos declarados en la interfaz java.util.Collection

Métodos declarados en la clase java.util.HashSet

Métodos declarados en la interfaz java.lang.Iterable

Métodos declarados en la interfaz java.util.Set

La siguiente es la diferencia entre LinkedHashMap y LinkedHashSet:

Nota: Mantener el orden de inserción tanto en LinkedHashmap como en LinkedHashset tiene costos asociados adicionales, tanto en términos de gasto de ciclos de CPU adicionales como de necesidad de más memoria. Si no necesita que se mantenga el orden de inserción, se recomienda utilizar HashSet y HashMap , que son más ligeros .

Este artículo es una contribución de Pratik Agarwal . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.