{"id":122313,"date":"2020-05-01T13:05:52","date_gmt":"2020-05-01T13:05:52","guid":{"rendered":"https:\/\/www.softwaretestinghelp.com\/?page_id=122313"},"modified":"2025-04-01T08:30:35","modified_gmt":"2025-04-01T08:30:35","slug":"java-arraylist-conversions","status":"publish","type":"page","link":"https:\/\/www.softwaretestinghelp.com\/java-arraylist-conversions\/","title":{"rendered":"Java ArrayList Conversions To Other Collections"},"content":{"rendered":"

This Tutorial Discusses ArrayList Conversions to other Collections like Set, LinkedList, Lists, etc. along with Differences Between These Collections:<\/strong><\/p>\n

So far we have seen almost all the concepts related to ArrayList in Java. Apart from creating and manipulating ArrayList using various operations or methods provided by ArrayList class, sometimes it is also required to convert ArrayList to one or more collections.<\/p>\n

=> Visit Here To Learn Java From Scratch.<\/a><\/strong><\/p>\n

<\/strong><\/em><\/p>\n

\"Array<\/a><\/p>\n

In this tutorial, we will discuss some of the conversions from ArrayList to other collections that include List, LinkedList, Vector, Set, etc. We will also consider conversion between ArrayList and String. After conversions, we will also discuss the differences between ArrayLists and other Collections – Arrays, List, Vector, LinkedList, etc.<\/strong><\/em><\/p>\n

ArrayList To String Conversion<\/h3>\n

The following methods can be used to convert ArrayList to String.<\/strong><\/p>\n

#1) Using a StringBuilder object<\/strong><\/p>\n

import java.util.ArrayList;\r\n\r\npublic class Main {\r\n   public static void main(String args[]) {\r\n       \/\/Create and initialize the ArrayList\r\n      ArrayList<String> strList = new ArrayList<String>();\r\n      strList.add("Software");\r\n      strList.add("Testing");\r\n      strList.add("Help");\r\n      \/\/print the ArrayList\r\n      System.out.println("The ArrayList: " + strList);\r\n      \/\/define a stringbuilder object     \r\n      StringBuffer sb = new StringBuffer();\r\n      \r\n      \/\/append each ArrayList element to the stringbuilder object\r\n      for (String str : strList) {\r\n         sb.append(str + " ");\r\n      }\r\n      \/\/convert stringbuilder to string and print it.\r\n      String myStr = sb.toString();\r\n      System.out.println("\\nString from ArrayList: " + myStr);\r\n   }\r\n} <\/pre>\n
Output:<\/strong><\/p>\n
The ArrayList: [Software, Testing, Help]
\nString from ArrayList: Software Testing Help<\/p>\n
\"output\"<\/a><\/p>\n
In the above program, a StringBuilder object is created. Then using the forEach loop, each element in the ArrayList is appended to the StringBuilder object. Then the StringBuilder object is converted to a string. Note that using the StringBuilder \u2018append\u2019 method; you can also append appropriate delimiter to the string.<\/p>\n
In the above example, we have used space (\u201c \u201c) as the delimiter.<\/p>\n
#2) Using String.join () method<\/strong><\/p>\n
The method String.join () can be used to convert the ArrayList to String. Here, you can also pass appropriate delimiter to the join method.<\/p>\n
 The program below demonstrates this.<\/strong><\/p>\n
import java.util.ArrayList;\r\n\r\npublic class Main {\r\n    public static void main(String[] args) {\r\n        \/\/ create and initialize the ArrayList\r\n        ArrayList<String> metroList = new ArrayList<>();\r\n        metroList.add("Delhi");\r\n        metroList.add("Mumbai");\r\n        metroList.add("Chennai");\r\n        metroList.add("Kolkata");\r\n        \/\/print the ArrayList\r\n        System.out.println("The ArrayList: " + metroList);\r\n        \/\/ Join with an empty delimiter to concat all strings.\r\n        String resultStr = String.join(" ", metroList);\r\n        System.out.println("\\nString converted from ArrayList: "+resultStr);\r\n    }\r\n}<\/pre>\n
Output:<\/strong><\/p>\n
The ArrayList: [Delhi, Mumbai, Chennai, Kolkata]
\nString converted from ArrayList: Delhi Mumbai Chennai Kolkata<\/p>\n
\"output\"<\/a><\/p>\n
You can see that we directly pass the ArrayList as an argument to the String.join () method along with the delimiter.<\/p>\n
For simple String ArrayLists, String.join () is the best method to convert to String. But for more complex ArrayLists objects, using StringBuilder is more efficient.<\/p>\n
String To ArrayList Conversion<\/h3>\n
In order to convert a String to ArrayList, there are two steps:<\/strong><\/p>\n
    \n
  1. The string is split using the split () function and the substrings (split on appropriate delimiter) are stored in a string array.<\/li>\n
  2. The string array obtained from splitting the string is then converted to ArrayList using \u2018asList()\u2019 method of the Arrays class.<\/li>\n<\/ol>\n
    The program to convert string to ArrayList is given below.<\/strong><\/p>\n
    import java.util.ArrayList;\r\nimport java.util.List;\r\nimport java.util.Arrays;\r\npublic class Main {\r\n    public static void main(String args[]){\r\n    \/\/define a string\r\n\tString myStr = "The string to ArrayList program";\r\n    \/\/convert string to array using split function on spaces\r\n\tString strArray[] = myStr.split(" ");\r\n\t\/\/print the string\r\n\tSystem.out.println("The input string : " + myStr);\r\n    \/\/declare an ArrayList\r\n\tList<String> strList = new ArrayList<String>();\r\n\t\/\/convert string array to ArrayList using asList method\r\n\tstrList = Arrays.asList(strArray);\r\n    \/\/print the resultant ArrayList\r\n    System.out.println("\\nThe ArrayList from String:" + strList );\r\n   }\r\n} <\/pre>\n
    Output:<\/strong><\/p>\n
    The input string: The string to ArrayList program
    \nThe ArrayList from String:[The, string, to, ArrayList, program]<\/p>\n
    \"output\"<\/a><\/p>\n
    In the above program, we split the string into spaces and collect it in a string array. This array is then converted into an ArrayList of strings.<\/p>\n
    Convert list To ArrayList In Java<\/h3>\n
    ArrayList implements the List interface. If you want to convert a List to its implementation like ArrayList, then you can do so using the addAll method of the List interface.<\/p>\n
    The program below shows the conversion of the list to ArrayList by adding all the list elements to the ArrayList.<\/strong><\/p>\n
    import java.util.ArrayList;\r\nimport java.util.List;\r\n \r\npublic class Main {\r\n    public static void main(String a[]){\r\n        \/\/create a list & initiliaze it\r\n        List<String> collections_List = new ArrayList<String>();\r\n        collections_List.add("ArrayList");\r\n        collections_List.add("Vector");\r\n        collections_List.add("LinkedList");\r\n        collections_List.add("Stack");\r\n        collections_List.add("Set");\r\n        collections_List.add("Map");\r\n        \/\/print the list\r\n        System.out.println("List contents: "+collections_List);\r\n        \/\/create an ArrayList        \r\n        ArrayList<String> myList = new ArrayList<String>();\r\n        \/\/use addAll() method to add list elements to ArrayList\r\n        myList.addAll(collections_List);\r\n        \/\/print the ArrayList\r\n        System.out.println("\\nArrayList after adding elements: "+myList);\r\n    }\r\n}\r\n<\/pre>\n
    Output:<\/strong><\/p>\n
    List contents: [ArrayList, Vector, LinkedList, Stack, Set, Map]
    \nArrayList after adding elements: [ArrayList, Vector, LinkedList, Stack, Set, Map]<\/p>\n
    \"output\"<\/a><\/p>\n
    Convert ArrayList To Set In Java<\/h3>\n
    The following methods convert an ArrayList to a Set.<\/strong><\/p>\n
    #1) Using a traditional iterative approach<\/strong><\/p>\n
    This is the traditional approach. Here, we iterate through the list and add each element of the ArrayList to the set.<\/p>\n
    In the program below, we have an ArrayList of string. We declare a HashSet of string. Then using the forEach loop, we iterate over the ArrayList and add each element to the HashSet.<\/p>\n
    In a similar manner, we can also convert ArrayList to a treeSet.<\/p>\n
    import java.util.*; \r\n  \r\nclass Main { \r\n    public static void main(String[] args)  { \r\n          \/\/ Create & initialize an ArrayList\r\n        ArrayList<String> colorsList = new ArrayList<String>\r\n        (Arrays.asList("Red", "Green", "Blue", "Cyan", "Magenta", "Yellow")); \r\n        \/\/print the ArrayList\r\n        System.out.println("The ArrayList:" + colorsList);\r\n        \/\/Declare a HashSet\r\n        Set<String> hSet = new HashSet<String>(); \r\n        \/\/Add each ArrayList element to the set\r\n        for (String x : colorsList) \r\n            hSet.add(x); \r\n        \/\/Print the HashSet  \r\n        System.out.println("\\nHashSet obtained from ArrayList: " + hSet); \r\n     } \r\n}\r\n<\/pre>\n
    Output:<\/strong><\/p>\n
    The ArrayList:[Red, Green, Blue, Cyan, Magenta, Yellow]
    \nHashSet obtained from ArrayList: [Red, Cyan, Blue, Yellow, Magenta, Green]<\/p>\n
    \"output\"<\/a><\/p>\n
    #2) Using Set Constructor<\/strong><\/p>\n
    The next method to convert an ArrayList to a set is using the constructor. In this method, we pass the ArrayList as an argument to the set constructor and thus initialize the set object with ArrayList elements.<\/p>\n
    The program below shows the use of ArrayList in creating a set object.<\/strong><\/p>\n
    import java.util.*; \r\n  \r\nclass Main { \r\n    public static void main(String[] args)  { \r\n          \/\/ Create & initialize an ArrayList\r\n        ArrayList<String> colorsList = new ArrayList<String>\r\n        (Arrays.asList("Red", "Green", "Blue", "Cyan", "Magenta", "Yellow")); \r\n        \/\/print the ArrayList\r\n        System.out.println("The ArrayList:" + colorsList);\r\n        \/\/Declare a TreeSet\r\n       Set<String> tSet = new TreeSet<String>(colorsList); \r\n       \/\/Print the TreeSet  \r\n        System.out.println("\\nTreeSet obtained from ArrayList: " + tSet); \r\n    } \r\n}\r\n<\/pre>\n
    Output:<\/strong><\/p>\n
    The ArrayList:[Red, Green, Blue, Cyan, Magenta, Yellow
    \nTreeSet obtained from ArrayList: [Blue, Cyan, Green, Magenta, Red, Yellow]<\/p>\n
    \"output\"<\/a><\/p>\n
    #3) Using The addAll Method<\/strong><\/p>\n
    You can also use the addAll method of Set to add all the elements of ArrayList to the set.<\/p>\n
    The following program uses the addAll method to add the elements of ArrayList to the HashSet.<\/strong><\/p>\n
    import java.util.*; \r\n \r\nclass Main { \r\n    public static void main(String[] args)  { \r\n        \/\/ Create & initialize an ArrayList\r\n        ArrayList<String> colorsList = new ArrayList<String>\r\n        (Arrays.asList("Red", "Green", "Blue", "Cyan", "Magenta", "Yellow")); \r\n        \/\/print the ArrayList\r\n        System.out.println("The ArrayList:" + colorsList);\r\n        \/\/Declare a HashSet\r\n        Set<String> hSet = new HashSet<String>(); \r\n        \/\/use addAll method of HashSet to add elements of ArrayList\r\n        hSet.addAll(colorsList);\r\n        \/\/Print the HashSet  \r\n        System.out.println("\\nHashSet obtained from ArrayList: " + hSet); \r\n     } \r\n}\r\n<\/pre>\n
     Output:<\/strong><\/p>\n
    The ArrayList:[Red, Green, Blue, Cyan, Magenta, Yellow]
    \nHashSet obtained from ArrayList: [Red, Cyan, Blue, Yellow, Magenta, Green]<\/p>\n
    \"output\"<\/a><\/p>\n
    #4) Using Java 8 Stream<\/strong><\/p>\n
    Streams are the new additions to Java 8. This stream class provides a method to convert ArrayList to stream and then to set.<\/p>\n
    The Java program below demonstrates the use of the stream class method to convert ArrayList to set.<\/strong><\/p>\n
    import java.util.*; \r\nimport java.util.stream.*; \r\nclass Main { \r\n    public static void main(String[] args)  { \r\n        \/\/ Create & initialize an ArrayList\r\n        ArrayList<String> colorsList = new ArrayList<String>\r\n        (Arrays.asList("Red", "Green", "Blue", "Cyan", "Magenta", "Yellow")); \r\n        \/\/print the ArrayList\r\n        System.out.println("The ArrayList:" + colorsList);\r\n        \r\n        \/\/ Convert ArrayList to set using stream \r\n        Set<String> set = colorsList.stream().collect(Collectors.toSet()); \r\n  \r\n        \/\/Print the Set  \r\n        System.out.println("\\nSet obtained from ArrayList: " + set); \r\n     } \r\n}\r\n<\/pre>\n
    Output:<\/strong><\/p>\n
    The ArrayList:[Red, Green, Blue, Cyan, Magenta, Yellow]
    \nSet obtained from ArrayList: [Red, Cyan, Blue, Yellow, Magenta, Green]<\/p>\n
    \"output\"<\/a><\/p>\n
    Convert Set To ArrayList In Java<\/h3>\n
    In the last section, we have seen the conversion of ArrayList to Set. The conversion from Set to ArrayList also uses the same methods as described above with the difference that the position of the set and ArrayList changes.<\/p>\n
    Given below are programming examples to convert Set to ArrayList. The other description for each method remains the same.<\/p>\n
    #1) Iterative Approach<\/strong><\/p>\n
    import java.util.*; \r\n  \r\nclass Main { \r\n  public static void main(String[] args) { \r\n      \/\/ Create a set of strings & add elements to it \r\n    Set<String> set = new HashSet<String>(); \r\n    set.add("One"); \r\n    set.add("Two"); \r\n    set.add("Three"); \r\n    \/\/print the set\r\n    System.out.println("The given Set: " + set); \r\n    \/\/create an ArrayList  \r\n    ArrayList<String> numList = new ArrayList<String>(set.size()); \r\n    \/\/add each set element to the ArrayList using add method\r\n    for (String str : set) \r\n      numList.add(str); \r\n  \r\n    \/\/print the ArrayList\r\n    System.out.println("\\nArrayList obtained from Set: " + numList); \r\n  } \r\n}\r\n<\/pre>\n
    Output:<\/strong><\/p>\n
    The given Set: [One, Two, Three]
    \nArrayList obtained from Set: [One, Two, Three]<\/p>\n
    \"output\"<\/a><\/p>\n
    In the above program, we iterate through the Set and each set element is added to the ArrayList.<\/p>\n
    #2) Using Constructor<\/strong><\/p>\n
    import java.util.*; \r\n  \r\nclass Main { \r\n  public static void main(String[] args) { \r\n    \/\/ Create a set of strings & add elements to it \r\n    Set<String> set = new HashSet<String>(); \r\n    set.add("One"); \r\n    set.add("Two"); \r\n    set.add("Three"); \r\n    \/\/print the set\r\n    System.out.println("The given Set: " + set); \r\n    \/\/create an ArrayList and pass set to the constructor \r\n    List<String> numList = new ArrayList<String>(set); \r\n     \/\/print the ArrayList\r\n    System.out.println("\\nArrayList obtained from Set: " + numList); \r\n  } \r\n}\r\n<\/pre>\n
    Output:<\/strong><\/p>\n
    The given Set: [One, Two, Three]
    \nArrayList obtained from Set: [One, Two, Three]<\/p>\n
    \"output\"<\/a><\/p>\n
    The above program creates a set and an ArrayList. The ArrayList object is created by providing a set object as an argument in its constructor.<\/p>\n
    #3) Using The addAll Method<\/strong><\/p>\n
    import java.util.*; \r\n  \r\nclass Main { \r\n  public static void main(String[] args) {   \r\n    \/\/ Create a set of strings & add elements to it \r\n    Set<String> set = new HashSet<String>(); \r\n    set.add("One"); \r\n    set.add("Two"); \r\n    set.add("Three"); \r\n    \/\/print the set\r\n    System.out.println("The given Set: " + set); \r\n    \/\/create an ArrayList \r\n    List<String> numList = new ArrayList<String>(); \r\n    \/\/use addAll method of ArrayList to add elements of set \r\n    numList.addAll(set); \r\n    \/\/print the ArrayList\r\n    System.out.println("\\nArrayList obtained from Set: " + numList); \r\n  } \r\n}\r\n<\/pre>\n
    Output:<\/strong><\/p>\n
    The given Set: [One, Two, Three]
    \nArrayList obtained from Set: [One, Two, Three]<\/p>\n
    \"output\"<\/a><\/p>\n
    Here, we use the addAll method of ArrayList to add the elements from the set to the ArrayList.<\/p>\n
    #4) Using Java 8 Stream<\/strong><\/p>\n
    import java.util.*; \r\nimport java.util.stream.*; \r\nclass Main { \r\n  public static void main(String[] args) { \r\n     \/\/ Create a set of strings & add elements to it \r\n    Set<String> set = new HashSet<String>(); \r\n    set.add("One"); \r\n    set.add("Two"); \r\n    set.add("Three"); \r\n    \/\/print the set\r\n    System.out.println("The given Set: " + set); \r\n    \/\/create an ArrayList and using stream method,assign stream of elements to ArrayList\r\n    List<String> numList = set.stream().collect(Collectors.toList()); \r\n  \r\n    \/\/print the ArrayList\r\n    System.out.println("\\nArrayList obtained from Set: " + numList); \r\n  } \r\n}\r\n<\/pre>\n
     Output:<\/strong><\/p>\n
    The given Set: [One, Two, Three]
    \nArrayList obtained from Set: [One, Two, Three]<\/p>\n
    \"output\"<\/a><\/p>\n
    The above program uses stream class to convert Set to ArrayList.<\/p>\n
    An Array Of ArrayList In Java<\/h3>\n
    An Array of ArrayList as the name suggests consists of ArrayLists as its elements. Though the feature is not used regularly, it is used when efficient usage of memory space is a requirement.<\/p>\n
    The following program implements an Array of ArrayLists in Java.<\/strong><\/p>\n
    import java.util.ArrayList;\r\nimport java.util.List;\r\n\r\npublic class Main {\r\n\tpublic static void main(String[] args) {\r\n\t\t\/\/define and initialize a num_list\r\n\t\tList<String> num_list = new ArrayList<>();\r\n\t\tnum_list.add("One");\r\n\t\tnum_list.add("Two");\r\n\t\tnum_list.add("Two");\r\n    \t\t\/\/define and initialize a colors_list\r\n\t\tList<String> colors_list = new ArrayList<>();\r\n\t\tcolors_list.add("Red");\r\n\t\tcolors_list.add("Green");\r\n\t\tcolors_list.add("Blue");\r\n\r\n        \t\t\/\/define Array of ArrayList with two elements\r\n\t\tList<String>[] arrayOfArrayList = new List[2];\r\n\t\t\/\/add num_list as first element \r\n\t\tarrayOfArrayList[0] = num_list;\r\n\t\t\/\/add colors_list as second element\r\n\t\tarrayOfArrayList[1] = colors_list;\r\n        \t\t\/\/print the contents of Array of ArrayList\r\n        \t\tSystem.out.println("Contents of Array of ArrayList:");\r\n\t\tfor (int i = 0; i < arrayOfArrayList.length; i++) {\r\n\t\t\tList<String> list_str = arrayOfArrayList[i];\r\n\t\t\tSystem.out.println(list_str);\r\n\t}\r\n}\r\n}<\/pre>\n
    Output:<\/strong><\/p>\n
    Contents of Array of ArrayList:
    \n[One, Two, Two]
    \n[Red, Green, Blue]<\/p>\n
    \"output\"<\/a><\/p>\n
    In the above program, we first define two lists. Then we declare an Array of two ArrayList. Each element of this array is the ArrayList defined earlier. Finally, the contents of an Array of ArrayList is displayed using a for loop.<\/p>\n
    ArrayList Of Arrays In Java<\/h3>\n
    Just as we have an Array of ArrayLists, we can also have ArrayList of Arrays. Here, each individual element of an ArrayList is an Array.<\/p>\n
    The below program demonstrates ArrayList of Arrays.<\/strong><\/p>\n
    import java.util.*;\r\n\r\npublic class Main {\r\n\tpublic static void main(String[] args) {\r\n\t\t\/\/ declare ArrayList of String arrays\r\n\t\tArrayList<String[]> ArrayList_Of_Arrays = new ArrayList<String[]>();\r\n\t\t\/\/define individual string arrays\r\n\t\tString[] colors = { "Red", "Green", "Blue" };\r\n\t\tString[] cities = { "Pune", "Mumbai", "Delhi"};\r\n\t\t\/\/add each array as element to ArrayList\r\n\t\tArrayList_Of_Arrays.add(colors);\r\n\t\tArrayList_Of_Arrays.add(cities);\r\n\t\t\/\/ print ArrayList of Arrays\r\n\t\tSystem.out.println("Contents of ArrayList of Arrays:");\r\n\t\tfor (String[] strArr : ArrayList_Of_Arrays) {\r\n\t\t\tSystem.out.println(Arrays.toString(strArr));\r\n\t\t}\r\n\t}\r\n}<\/pre>\n
    Output:<\/strong><\/p>\n
    Contents of ArrayList of Arrays:
    \n[Red, Green, Blue]
    \n[Pune, Mumbai, Delhi]<\/p>\n
    \"output\"<\/a><\/p>\n
    The above program demonstrates ArrayList of Arrays. Initially, we declare an ArrayList of String Arrays. This means each element of ArrayList will be a String Array. Next, we define two string Arrays. Then each of the Arrays is added to the ArrayList. Finally, we print the contents of ArrayList of Arrays.<\/p>\n
    To print the contents, we traverse the ArrayList using for loop. For each iteration, we print the contents of the ArrayList element which has an Array using Arrays.toString () method.<\/p>\n
    List Vs ArrayList In Java<\/h3>\n
    The following tables show some of the differences between a List and ArrayList.<\/strong><\/p>\n\n\n\n\n\t\n\n\t\n\t\n\t\n\t\n\t
    List<\/th>ArrayList<\/th>\n<\/tr>\n<\/thead>\n
    The list is an interface in Java<\/td>ArrayList is a part of the Java Collection framework<\/td>\n<\/tr>\n
    The list is implemented as an interface<\/td>ArrayList is implemented as a collection class <\/td>\n<\/tr>\n
    Extends Collection Interface<\/td>implements List interface & extends AbstractList<\/td>\n<\/tr>\n
    Part of System.Collection.generic namespace<\/td>Part of System.Collections namespace<\/td>\n<\/tr>\n
    Using List, a list of elements can be created which can be accessed using indices.<\/td>Using ArrayList, we can create a dynamic Array of elements or objects whose size automatically alters with the changes in contents.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n\n
    Vector Vs ArrayList<\/h3>\n
    Given below are some of the differences between a Vector and an ArrayList.<\/strong><\/p>\n\n\n\n\n\t\n\n\t\n\t\n\t\n\t\n\t
    ArrayList<\/th>LinkedList<\/th>\n<\/tr>\n<\/thead>\n
    ArrayList implements List interface<\/td>LinkedList implements List and Deque interfaces.<\/td>\n<\/tr>\n
    Data storage and access are efficient in ArrayList.<\/td>LinkedList is good at manipulating data.<\/td>\n<\/tr>\n
    ArrayList internally implements a dynamic array.<\/td>LinkedList internally implements a doubly linked list.<\/td>\n<\/tr>\n
    Since ArrayList internally implements dynamic array, the addition\/deletion of elements is slow as a lot of bit-shifting is required.<\/td>LinkedList is faster as far as addition\/removal of elements is concerned since no bit shifting is necessary.<\/td>\n<\/tr>\n
    Less memory overhead since in ArrayList only actual data is stored.<\/td>More memory overhead since each node in LinkedList contains data as well as the address to the next node.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n\n
    ArrayList vs LinkedList<\/h3>\n
    Let us now discuss the various differences between an ArrayList and a LinkedList.<\/span><\/p>\n\n\n\n\n\t\n\n\t\n\t\n\t\n\t\n\t
    ArrayList<\/th>LinkedList<\/th>\n<\/tr>\n<\/thead>\n
    ArrayList implements List interface<\/td>LinkedList implements List and Deque interfaces.<\/td>\n<\/tr>\n
    Data storage and access are efficient in ArrayList.<\/td>LinkedList is good at manipulating data.<\/td>\n<\/tr>\n
    ArrayList internally implements a dynamic array.<\/td>LinkedList internally implements a doubly linked list.<\/td>\n<\/tr>\n
    Since ArrayList internally implements dynamic array, the addition\/deletion of elements is slow as a lot of bit-shifting is required.<\/td>LinkedList is faster as far as addition\/removal of elements is concerned since no bit shifting is necessary.<\/td>\n<\/tr>\n
    Less memory overhead since in ArrayList only actual data is stored.<\/td>More memory overhead since each node in LinkedList contains data as well as the address to the next node.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n\n
    Frequently Asked Questions<\/h3>\n
    Q #1) How do you convert an ArrayList to an Array in Java?<\/strong><\/span><\/p>\n
    Answer:<\/strong> To convert an ArrayList to an Array in Java, one can use the toArray ( ) method from ArrayList API that converts a given ArrayList to an Array.<\/p>\n
    Q #2) <\/span><\/strong>How do you split a string and store it in an ArrayList in Java?<\/strong><\/span><\/p>\n
    Answer:<\/strong> The string is split using a split () function. This method returns an Array of strings. Then using the Arrays.asList () method, the string array can be converted to an ArrayList of strings.<\/p>\n
    Q #3) What is the default size of an ArrayList?<\/strong><\/span><\/p>\n
    Answer:<\/strong> An ArrayList object created without specifying the capacity has a size 0 as there are no elements added to the list. But the default capacity of this ArrayList is 10.<\/p>\n
    Q #4) What is the difference between length () and size () of ArrayList?<\/strong><\/span><\/p>\n
    Answer:\u00a0<\/strong>An ArrayList does not have a length () property or method. It provides only the size () method that returns the total number of elements in the ArrayList.<\/p>\n
    Q #5) What is the difference between the capacity and size of ArrayList?<\/strong><\/span><\/p>\n
    Answer:<\/strong> ArrayList possesses both capacity and size. Capacity is the total size of the ArrayList or the total number of elements it can hold. Size is the number of elements or locations that have data in them.<\/p>\n
    For example,<\/span><\/strong> if ArrayList capacity is 10 and its size is 5, this means that an ArrayList can hold up to 10 elements, but at present only 5 locations have data in them.<\/p>\n
    Conclusion<\/h3>\n
    In this tutorial, we discussed some of the additional concepts related to ArrayList like converting ArrayList to a string, list, set, and vice versa. We also discussed the differences between ArrayList and Vector, ArrayList and LinkedList, etc.<\/p>\n
    In our upcoming tutorial, we will take up another collection and learn it thoroughly.<\/strong><\/em><\/p>\n
    => Check Here To See A-Z Of Java Training Tutorials Here.<\/a><\/strong><\/p>\n\r\n\t\t\t
    \r\n\r\n\t\t\t\t
    \r\n\t\t\t\t\t
    \r\n\t\t\t\t\t\t
    Was this helpful?<\/h3>\r\n\t\t\t\t\t<\/div>\r\n\t\t\t\t\t
    \r\n\t\t\t\t\t\t
    \r\n\t\t\t\t\t\t\t\r\n\t\t\t
    \r\n\t\t\t\t\r\n                \r\n                    \r\n                        
    \r\n\t\t\t\t\r\n                \r\n                    \r\n                        
    \r\n\t\t\t\t\t
    \r\n\t\t\t\t\t\t