¿Cómo convertir ArrayList a LinkedHashSet en Java?

ArrayList es una estructura de datos que supera las deficiencias de la array común en Java en la que el tamaño debe especificarse explícitamente de antemano. La longitud de la estructura de datos de la array no se puede modificar, lo cual se hace cargo de la estructura de datos ArrayList . Esta estructura de datos también se conoce como array dinámica y puede crecer o modificarse según sea necesario. Es una clase bajo el marco de Collections y se puede incluir en el programa java importando el paquete java.util . 

LinkedHashSet es una versión mejorada de la clase HashSet tradicional en Java al proporcionar la funcionalidad adicional de ordenar que faltaba en HashSet. Mantiene el orden en el que se insertaron los elementos, a diferencia del HashSet, donde el orden era impredecible. Se implementa usando una lista doblemente enlazada y se puede iterar usando el iterador.

Este artículo trata sobre la conversión de ArrayList a LinkedHashSet utilizando 4 enfoques diferentes que se enumeran a continuación:

1. Pasar ArrayList como parámetro durante la inicialización del constructor LinkedHashSet.
2. Usando el método addAll() de la clase LinkedHashSet.
3. Usando el método add() de la clase LinkedHashSet mientras itera sobre todos los elementos de ArrayList.
4. Usando stream para convertir primero ArrayList en Set, que luego se convierte en LinkedHashSet.

Enfoque 1

Usando este enfoque, simplemente pasamos ArrayList como un parámetro mientras inicializamos la clase LinkedHashSet

Sintaxis

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

LinkedHashSet<E> hs = nuevo LinkedHashSet<E>(Colección c);

Ejemplo

// java program to convert ArrayList
// to LinkedHashSet
 
// importing the utils package
import java.util.*;
 
class GFG {
 
    // defining the method
    void arrayListToLinkedHashSet()
    {
 
        // initializing the ArrayList
        ArrayList<String> arrayList = new ArrayList<>();
 
        // adding values in the ArrayList
        arrayList.add("Geeks");
        arrayList.add("For");
        arrayList.add("Geeks");
 
        // printing the list
        System.out.println("The array list : " + arrayList);
 
        // initializing the LinkedHashSet class
        // passing the ArrayList as parameter
        LinkedHashSet<String> linkedHashSet
            = new LinkedHashSet<String>(arrayList);
 
        // printing the LinkedHashSet
        System.out.println("The converted "
                           + "Linked Hash Set : "
                           + linkedHashSet);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // instantiating the class
        GFG ob = new GFG();
 
        // calling the method
        ob.arrayListToLinkedHashSet();
    }
}

The array list : [Geeks, For, Geeks]
The converted Linked Hash Set : [Geeks, For]

Explicación:
ArrayList contiene tres entradas que son [Geeks, For, Geeks]. Esto se convierte en un conjunto ordenado y solo contiene dos valores: Geeks y For. Dado que Set no permite múltiples valores similares.

Enfoque 2

Usando este enfoque, usamos el método predefinido addAll() de la clase LinkedHashSet después de inicializarlo para llenar el LinkedHashSet.

Sintaxis: 

LinkedHashSet.addAll(Collection C)

Parámetros: el parámetro C es una colección de cualquier tipo que se agregará al conjunto.

Valor de retorno: el método devuelve verdadero si agrega con éxito los elementos de la colección C a este conjunto; de lo contrario, devuelve falso.

Ejemplo 

// java program to convert ArrayList
// to LinkedHashSet
 
// importing the java.utils package
import java.util.*;
 
class GFG {
 
    // defining the method
    void arrayListToLinkedHashSet()
    {
 
        // initializing the ArrayList
        ArrayList<String> arrayList = new ArrayList<>();
 
        // filling the ArrayList with values
        arrayList.add("Geeks");
        arrayList.add("For");
        arrayList.add("Geeks");
 
        // printing the list
        System.out.println("The Array List : " + arrayList);
 
        // initializing the LinkedHashSet
        LinkedHashSet<String> linkedHashSet
            = new LinkedHashSet<>();
 
        // using the addAll() to
        // fill the HashSet
        linkedHashSet.addAll(arrayList);
 
        // printing the LinkedHashSet
        System.out.println("The Linked "
                           + "Hash Set : " + linkedHashSet);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // instantiating the class
        GFG ob = new GFG();
 
        // calling the method
        ob.arrayListToLinkedHashSet();
    }
}

The Array List : [Geeks, For, Geeks]
The Linked Hash Set : [Geeks, For]

Enfoque 3

Usando este enfoque, iteramos sobre ArrayList y en cada iteración llenamos LinkedHashSet con el valor usando el método add() predefinido de la clase LinkedHashSet.

Sintaxis: 

Hash_Set.add(Object element)

Parámetros: El elemento parámetro es del tipo LinkedHashSet y hace referencia al elemento que se agregará al Conjunto.

Valor de retorno: la función devuelve True si el elemento no está presente en LinkedHashSet; de lo contrario, False si el elemento ya está presente en LinkedHashSet.

Ejemplo 

// java program to convert ArrayList
// to LinkedHashSet
 
// importing the java.utils package
import java.util.*;
 
class GFG {
 
    // defining the method
    void arrayListToHashSet()
    {
 
        // initializing the ArrayList
        ArrayList<String> arrayList = new ArrayList<>();
 
        // filling the ArrayList with values
        arrayList.add("Geeks");
        arrayList.add("For");
        arrayList.add("Geeks");
 
        // printing the list
        System.out.println("The Array List : " + arrayList);
 
        // declaring the iterator
        Iterator<String> itr = arrayList.iterator();
 
        // initializing the LinkedHashSet
        LinkedHashSet<String> linkedHashSet
            = new LinkedHashSet<>();
 
        // loop to iterate through the ArrayList
        while (itr.hasNext())
 
            // using the add()
            // to fill the HashSet
            linkedHashSet.add(itr.next());
 
        // printing the LinkedHashSet
        System.out.println("The Linked Hash Set : "
                           + linkedHashSet);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // instantiating the class
        GFG ob = new GFG();
 
        // calling the method
        ob.arrayListToHashSet();
    }
}

The Array List : [Geeks, For, Geeks]
The Linked Hash Set : [Geeks, For]

Enfoque 4

Bajo este enfoque, primero convertimos ArrayList en una secuencia que luego se convierte en un Conjunto. Este conjunto finalmente se convierte en un LinkedHashSet. La clase de transmisión solo está disponible para las versiones 8 o superior de JDK.

Ejemplo 

// java program to convert ArrayList
// to LinkedHashSet
 
import java.util.*;
import java.util.stream.*;
 
class GFG {
 
    // defining the method
    void arrayListToLinkedHashSet()
    {
 
        // initializing the ArrayList
        ArrayList<String> arrayList = new ArrayList<>();
 
        // filling the ArrayList with values
        arrayList.add("Geeks");
        arrayList.add("For");
        arrayList.add("Geeks");
 
        // printing the list
        System.out.println("The Array List : " + arrayList);
 
        // creating a stream from the ArrayList
        Stream<String> stream = arrayList.stream();
 
        // creating a set from the Stream
        // using the predefined toSet()
        // method of the Collectors class
        Set<String> set
            = stream.collect(Collectors.toSet());
 
        // converting the Set to
        // LinkedHashSet
        LinkedHashSet<String> linkedHashSet
            = new LinkedHashSet<>(set);
 
        // printing the LinkedHashSet
        System.out.println("The Linked Hash Set : "
                           + linkedHashSet);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // instantiating the class
        GFG ob = new GFG();
 
        // calling the method
        ob.arrayListToLinkedHashSet();
    }
}

The Array List : [Geeks, For, Geeks]
The Linked Hash Set : [Geeks, For]

Conversión de ArrayList de objetos de clase personalizados a LinkedHashSet

Los ejemplos anteriores ilustran el procedimiento para convertir ArrayList de tipos de datos primitivos como Integer, String, etc. Aquí, vamos a utilizar los enfoques anteriores para convertir una ArrayList de objetos de clase personalizados en LinkedHashSet. Una característica interesante de la conversión es que permite la duplicación de objetos que no estaba permitida en los escenarios anteriores. La razón de lo mismo es que cada vez que se crea un nuevo objeto de la misma clase y el método equals() que se usa para verificar elementos antes de ingresarlos en el conjunto cuando compara los objetos, encuentra referencias únicas ya que cada nuevo objeto tiene un nueva referencia. Esto permite que los mismos datos estén presentes en LinkedHashSet en más de un lugar.

Ejemplo

// java code to convert an ArrayList
// of custom class objects to
// LinkedHashSet
 
// importing the libraries
import java.util.*;
 
// the custom class
class Sports {
 
    // global variable name of type String
    // to hold the name of the sport
    private String name;
 
    // constructor
    public Sports(String name)
    {
 
        // initializing the name
        this.name = name;
    }
 
    // method to return the string
    public String returnString()
    {
        return name + " is a great sport";
    }
}
 
// primary class
class GFG {
 
    // declaring the method
    static void arrayListToLinkedHashSet()
    {
 
        // creating an array list of type
        // class Sports
        ArrayList<Sports> listOfSports
            = new ArrayList<Sports>();
 
        // adding the new instances of Sports
        // in the array list
        listOfSports.add(new Sports("Football"));
        listOfSports.add(new Sports("Basketball"));
        listOfSports.add(new Sports("Football"));
 
        // printing the list
        System.out.println("The Array List : "
                           + listOfSports);
 
        // declaring an iterator of type Sports
        // to iterate over the list
        Iterator<Sports> itr = listOfSports.iterator();
 
        // iterating over the list
        while (itr.hasNext())
 
            // printing the contents
            // by calling the returnString()
            System.out.println(itr.next().returnString());
 
        // initializing the linkedhashset
        // of type Sports
        LinkedHashSet<Sports> linkedHashSet
            = new LinkedHashSet<Sports>(listOfSports);
 
        // printing the contents of the
        // linked hash set
        System.out.println("The Linked Hash Set : "
                           + linkedHashSet);
 
        // declaring an iterator to iterate
        // over linkedhashset
        Iterator<Sports> itr1 = linkedHashSet.iterator();
 
        // iterating over the linkedhashset
        while (itr1.hasNext()) {
 
            // calling the returnString()
            // of Sports
            System.out.println(itr1.next().returnString());
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // calling the method
        arrayListToLinkedHashSet();
    }
}

The Array List : [Sports@4e50df2e, Sports@1d81eb93, Sports@7291c18f]
Football is a great sport
Basketball is a great sport
Football is a great sport
The Linked Hash Set : [Sports@4e50df2e, Sports@1d81eb93, Sports@7291c18f]
Football is a great sport
Basketball is a great sport
Football is a great sport

Explicación:
En la primera línea se imprime el contenido de ArrayList que como se puede ver son referencias a la clase Sports. En las siguientes tres líneas, se imprimen los contenidos del método returnString() de la clase Sports. Cabe señalar que todas las referencias son únicas y, por lo tanto, LinkedHashSet las permite aunque el contenido sea el mismo. En la siguiente línea, se imprime el contenido de LinkedHashSet, que nuevamente son referencias a la clase Sports. Las líneas siguientes son las llamadas al método returnString() .