Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Java Program to Convert ArrayList to LinkedList

  • Difficulty Level : Easy
  • Last Updated : 28 Oct, 2021

Given an array list, your task is to write a program to convert the given array list to Linked List in Java. 

Examples: 

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 – An ArrayList is a part of the collection framework and is present in java.util package. It provides us dynamic arrays in Java. Though, it may be slower than standard arrays but can be helpful in programs where lots of manipulation in the array is needed.

Linked List – A linked list is a linear data structure, in which the elements are not stored at contiguous memory locations. The elements in a linked list are linked using pointers as shown in the below image: 
 

Approaches

There are numerous approaches to convert the given array list to a linked list in Java. A few of them are listed below.

  • Using Brute Force or Naive Method
  • Using List Constructor
  • Using Java 8 Streams API
  • Using Google’s Guava Library
  • Conversion between incompatible types

1. Using Brute Force or Naive Method

In this method, an empty LinkedList is created and all elements present of the ArrayList are added to it one by one.

Algorithm

  • Get the ArrayList to be converted.
  • Create an empty LinkedList.
  • Iterate through the items in the ArrayList.
  • For each item, add it to LinkedList.
  • Return the formed LinkedList.

Code:

Java




// 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);
    }
}
Output
ArrayList: [Geeks, forGeeks, A computer Portal]
LinkedList: [Geeks, forGeeks, A computer Portal]

2. Using List Constructor

In this method, the ArrayList is passed as the parameter into the LinkedList constructor.

Algorithm

  • Get the ArrayList to be converted.
  • Create the LinkedList by passing the ArrayList as parameter in the constructor of the LinkedList.
  • Return the formed LinkedList.

Code:



Java




// 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);
    }
}
Output
ArrayList: [Geeks, forGeeks, A computer Portal]
LinkedList: [Geeks, forGeeks, A computer Portal]

3. Using Java 8 Stream API 

This method includes converting the ArrayList to a Stream and collect elements of a stream in a LinkedList using Stream.collect() method which accepts a collector.

Algorithm

  • Get the ArrayList to be converted.
  • Convert the ArrayList into the stream.
  • Using Collectors, collect the ArrayList Stream and convert it into LinkedList.
  • Now collect the LinkedList.
  • Return the formed LinkedList.

Code:

Java




// 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);
    }
}
Output
ArrayList: [Geeks, forGeeks, A computer Portal]
LinkedList: [Geeks, forGeeks, A computer Portal]

4. Using Google’s Guava library

Guava also provides a LinkedList implementation which can be used to create a LinkedList from another collection using Collection.addAll() method.

Algorithm

  • Get the ArrayList to be converted.
  • Create an empty LinkedList.
  • Add the elements of the ArrayList into the LinkedList using LinkedList.addAll() method and passing the ArrayList as the parameter.
  • Return the formed LinkedList.

Code:

Java




// 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);
    }
}
Output
ArrayList: [Geeks, forGeeks, A computer Portal]
LinkedList: [Geeks, forGeeks, A computer Portal]

5. Conversion between incompatible types

This method can be used if the required TreeMap is of the different type than the HashMap. In this, the conversion needs to be done manually.

Algorithm

  • Get the ArrayList to be converted.
  • Convert the ArrayList into the stream.
  • Convert the stream elements into the desired type by casting. This can be done by passing the casting function as parameter to map() function.
  • Using Collectors, collect the ArrayList Stream and convert it into LinkedList.
  • Now collect the LinkedList.
  • Return the formed LinkedList.

Code:

Java




// 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);
    }
}
Output
ArrayList: [1, 2, 3, 4, 5]
LinkedList: [1, 2, 3, 4, 5]


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!