Programa Java para convertir ArrayList a LinkedList

Dada una lista de arreglos, su tarea es escribir un programa para convertir la lista de arreglos dada en una lista enlazada en Java. 

Ejemplos: 

Input: ArrayList: [Geeks, forGeeks, A computer Portal] 
Output: LinkedList: [Geeks, forGeeks, A computer Portal]
Input: ArrayList: [1, 2, 3, 4, 5] 
Output: LinkedList: [1, 2, 3, 4, 5] 

ArrayList: una ArrayList es parte del marco de la colección y está presente en el paquete java.util . Nos proporciona arreglos dinámicos en Java. Sin embargo, puede ser más lento que las arrays estándar, pero puede ser útil en programas donde se necesita mucha manipulación en la array.

Lista enlazada: una lista enlazada es una estructura de datos lineal, en la que los elementos no se almacenan en ubicaciones de memoria contiguas. Los elementos de una lista vinculada se vinculan mediante punteros como se muestra en la siguiente imagen: 
 

Enfoques

Existen numerosos enfoques para convertir la lista de arrays dada en una lista vinculada en Java. Algunos de ellos se enumeran a continuación.

• Uso de fuerza bruta o método ingenuo
• Uso del constructor de listas
• Uso de la API de secuencias de Java 8
• Uso de la biblioteca de guayaba de Google
• Conversión entre tipos incompatibles

1. Usar fuerza bruta o método ingenuo

En este método, se crea una LinkedList vacía y todos los elementos presentes de ArrayList se agregan uno por uno.

Algoritmo : 

• Obtenga el ArrayList que se va a convertir.
• Cree una LinkedList vacía.
• Iterar a través de los elementos en ArrayList.
• Para cada elemento, agréguelo a LinkedList.
• Devuelve la LinkedList formada.

Código:

// Java Program to convert
// ArrayList to LinkedList 
// using Naive method
  
import java.util.*;
import java.util.stream.*;
  
class GFG {
  
    // Generic function to convert an ArrayList to LinkedList
    public static <T> List<T> convertALtoLL(List<T> aL)
    {
  
        // Create an empty LinkedList
        List<T> lL = new LinkedList<>();
  
        // Iterate through the aL
        for (T t : aL) {
  
            // Add each element into the lL
            lL.add(t);
        }
  
        // Return the converted LinkedList
        return lL;
    }
  
    public static void main(String args[])
    {
        // Create an ArrayList
        List<String> aL = Arrays.asList("Geeks",
                                    "forGeeks",
                                    "A computer Portal");
  
        // Print the ArrayList
        System.out.println("ArrayList: " + aL);
  
        // convert the ArrayList to LinkedList
        List<String>
            lL = convertALtoLL(aL);
  
        // Print the LinkedList
        System.out.println("LinkedList: " + lL);
    }
}

ArrayList: [Geeks, forGeeks, A computer Portal]
LinkedList: [Geeks, forGeeks, A computer Portal]

2. Usando el constructor de listas

En este método, ArrayList se pasa como parámetro al constructor LinkedList.

Algoritmo : 

• Obtenga el ArrayList que se va a convertir.
• Cree LinkedList pasando ArrayList como parámetro en el constructor de LinkedList.
• Devuelve la LinkedList formada.

Código:

// Java Program to convert
// ArrayList to LinkedList
// using List Constructor
  
import java.util.*;
import java.util.stream.*;
  
class GFG {
  
    // Generic function to convert an ArrayList to LinkedList
    public static <T> List<T> convertALtoLL(List<T> aL)
    {
  
        // Create the LinkedList by passing the ArrayList
        // as parameter in the constructor
        List<T> lL = new LinkedList<>(aL);
  
        // Return the converted LinkedList
        return lL;
    }
  
    public static void main(String args[])
    {
        // Create an ArrayList
        List<String> aL = Arrays.asList("Geeks",
                                    "forGeeks",
                                    "A computer Portal");
  
        // Print the ArrayList
        System.out.println("ArrayList: " + aL);
  
        // convert the ArrayList to LinkedList
        List<String>
            lL = convertALtoLL(aL);
  
        // Print the LinkedList
        System.out.println("LinkedList: " + lL);
    }
}

ArrayList: [Geeks, forGeeks, A computer Portal]
LinkedList: [Geeks, forGeeks, A computer Portal]

3. Uso de la API de flujo de Java 8 

Este método incluye convertir ArrayList en Stream y recopilar elementos de un flujo en LinkedList mediante el método Stream.collect() que acepta un recopilador.

Algoritmo : 

• Obtenga el ArrayList que se va a convertir.
• Convierta ArrayList en la secuencia.
• Utilizando Collectors, recopile ArrayList Stream y conviértalo en LinkedList.
• Ahora recopile la LinkedList.
• Devuelve la LinkedList formada.

Código:

// Java Program to convert
// ArrayList to LinkedList
// using Streams API
  
import java.util.*;
import java.util.stream.*;
  
class GFG {
  
    // Generic function to convert an
    // ArrayList to LinkedList
    public static <T> List<T> convertALtoLL(
                                        List<T> aL)
    {
  
        // Return the converted LinkedList
        return aL
  
            // Convert the ArrayList into Stream
            .stream()
  
            // Collect the LinkedList
            .collect(Collectors
  
            // Convert the Stream into LinkedList
            // Collection type
            .toCollection(LinkedList::new));
    }
  
    public static void main(String args[])
    {
        // Create an ArrayList
        List<String> aL = Arrays.asList("Geeks",
                                        "forGeeks",
                                        "A computer Portal");
  
        // Print the ArrayList
        System.out.println("ArrayList: " + aL);
  
        // convert the ArrayList to LinkedList
        List<String> lL = convertALtoLL(aL);
  
        // Print the LinkedList
        System.out.println("LinkedList: " + lL);
    }
}

ArrayList: [Geeks, forGeeks, A computer Portal]
LinkedList: [Geeks, forGeeks, A computer Portal]

4. Usando la biblioteca Guayaba de Google

Guava también proporciona una implementación de LinkedList que se puede usar para crear una LinkedList de otra colección usando el método Collection.addAll().

Algoritmo : 

• Obtenga el ArrayList que se va a convertir.
• Cree una LinkedList vacía.
• Agregue los elementos de ArrayList a LinkedList usando el método LinkedList.addAll() y pasando ArrayList como parámetro.
• Devuelve la LinkedList formada.

Código:

// Java Program to convert
// ArrayList to LinkedList
// using Google's Guave library
  
import java.util.*;
import java.util.stream.*;
  
class GFG {
  
    // Generic function to convert an ArrayList
    // to LinkedList
    public static <T> List<T> convertALtoLL(List<T> aL)
    {
  
        // Create an empty LinkedList
        List<T> lL = new LinkedList<>();
  
        // Add ArrayList into the lL
        lL.addAll(aL);
  
        // Return the converted LinkedList
        return lL;
    }
  
    public static void main(String args[])
    {
        // Create an ArrayList
        List<String> aL = Arrays.asList("Geeks",
                                    "forGeeks",
                                    "A computer Portal");
  
        // Print the ArrayList
        System.out.println("ArrayList: " + aL);
  
        // convert the ArrayList to LinkedList
        List<String>
            lL = convertALtoLL(aL);
  
        // Print the LinkedList
        System.out.println("LinkedList: " + lL);
    }
}

ArrayList: [Geeks, forGeeks, A computer Portal]
LinkedList: [Geeks, forGeeks, A computer Portal]

5. Conversión entre tipos incompatibles

Este método se puede usar si el TreeMap requerido es de un tipo diferente al HashMap. En esto, la conversión debe hacerse manualmente.

Algoritmo : 

• Obtenga el ArrayList que se va a convertir.
• Convierta ArrayList en la secuencia.
• Convierta los elementos de flujo en el tipo deseado mediante la conversión. Esto se puede hacer pasando la función de conversión como parámetro a la función map().
• Utilizando Collectors, recopile ArrayList Stream y conviértalo en LinkedList.
• Ahora recopile la LinkedList.
• Devuelve la LinkedList formada.

Código:

// Java Program to convert
// ArrayList to LinkedList for
// Conversion between incompatible types
  
import java.util.*;
import java.util.stream.*;
  
class GFG {
  
    // Generic function to convert an ArrayList to LinkedList
    public static <T> List<String> convertALtoLL(List<T> aL)
    {
  
        // Return the converted LinkedList
        return aL
  
            // Convert the ArrayList into Stream
            .stream()
  
            // Convert the Stream into String
            // Desired casting function can be passed
            // as parameter in next step
            .map(String::valueOf)
  
            // Collect the LinkedList
            .collect(Collectors
  
            // Convert the Stream into LinkedList
            // Collection type
            .toCollection(LinkedList::new));
    }
  
    public static void main(String args[])
    {
        // Create an ArrayList
        List<Integer> aL = Arrays.asList(1, 2, 3, 4, 5);
  
        // Print the ArrayList
        System.out.println("ArrayList: " + aL);
  
        // convert the ArrayList to LinkedList
        List<String> lL = convertALtoLL(aL);
  
        // Print the LinkedList
        System.out.println("LinkedList: " + lL);
    }
}

ArrayList: [1, 2, 3, 4, 5]
LinkedList: [1, 2, 3, 4, 5]