datatype array_name = new dataype[Size_of_Array];\r\n<\/pre>\nExample Array in Java:<\/strong><\/p>\n
int Arr = new int[100];\r\n<\/pre>\nWhat is an ArrayList in Java?<\/h3>\n
Unlike Array, ArrayList is a dynamic data structure that is part of the java collection framework. It also contains elements of the same type. Here we do not need to specify the size of the list.<\/p>\n
ArrayList in Java has the power to increase or decrease the size of an array, allowing the updating and deletion of data after the array is created.<\/p>\n
Syntax of ArrayList in Java:<\/strong><\/p>\n
ArrayList <Wrapper Class> object_name=new ArrayList<Wrapper Class>();\r\n<\/pre>\nExample of ArrayList in Java:<\/strong><\/p>\n
ArrayList <Integer> Arr=new ArrayList<Integer>();\r\n<\/pre>\nSimilarities Between Java Array and ArrayList<\/h3>\n
\n
- Array and ArrayList are both Data structures used to store data of the same type.<\/li>\n
- Null values can be stored in both Array and ArrayList.<\/li>\n
- Duplicate values can be incorporated into them, but the data type has to be the same.<\/li>\n
- The order of the elements is not preserved.<\/li>\n
- Both the array and the array list arrange the item by using indexing.<\/li>\n
- For iterating the element of an array and array list, loops can be used.<\/li>\n<\/ul>\n
Now that we have seen the similarities between them, in reality, they are quite different.<\/p>\n
Let us discuss the differences between them in detail.<\/p>\n
Difference Between Java Array vs ArrayList<\/h3>\n
1. Nature:<\/strong> Arrays are static data structures in nature. This means, once declared, the size of the array cannot be altered whatsoever. Meanwhile, ArrayList is a dynamic data structure. We do not need to specify any length of ArrayList while declaring it. The size of ArrayList grows in size when and where needed.<\/p>\n
2. Implementation:<\/strong> Array is by default incorporated into the JVM. It is a fundamental feature of the Java Programming Language. Meanwhile, ArrayList is present in the Java Collection Framework API. ArrayList is a class that uses Array implicitly to perform various tasks. We can create objects of the ArrayList class and call methods with it. An array on the other hand is a composite data type of java. We cannot call methods with an array except length.<\/p>\n
3. Performance:<\/strong> Since ArrayList implicitly uses Array, we might think they perform at the same speed. It is partially correct. ArrayList performs all the basic functionalities with the same speed as an Array. But ArrayList performs various extra functions that perform slowly as it affects the CPU memory. For example, if we resize the ArrayList, it would copy the content of the array to another array then resize it. This slows down the performance of ArrayList.<\/p>\n
4. Flexibility:<\/strong> It is one of the main differences between an Array and an ArrayList. ArrayList is far more flexible when compared to an array. An array is a static data structure and is very hard to resize. Meanwhile, ArrayList is very flexible and changes the size very easily and automatically. This makes ArrayList a lot more flexible when compared to arrays. Moreover, we can easily add or remove elements from an ArrayList, whereas arrays do not provide such facilities. It is very hard to remove elements from an array once added.<\/p>\n
Example:<\/strong><\/p>\n
Integer intObject[] = new Integer[100];\r\nintObject[0] = new Integer(21); \/\/new Wrapper class object is added to the array object\r\n<\/pre>\n5. Type<\/strong> of data stored:<\/strong> Arrays can contain any element from primitive data to object of a class. Whereas ArrayList contains only objects, it cannot have primitive data in it. However, there is a workaround to it, we can use autoboxing to store primitive data values. Let us see how using an example:<\/strong><\/p>\n
ArrayList Arr = new ArrayList();\r\nArr.add(21); \/\/ add 21 int primitive data type\r\n<\/pre>\nThis is possible because ArrayList uses wrapper class objects to store data.<\/p>\n
6. Generics:<\/strong> Generics is a feature in java that was added in the year 2004. A major difference between array and ArrayList is that ArrayList supports generics while array does not support generics. The reason being that array is of covariant type while generics are invariant. This is why the compiler doesn\u2019t allow arrays to store generics. ArrayLists do not have such problems.<\/p>\n
7. Iteration:<\/strong> Iteration is very important when it comes to data handling, as we have to traverse through the data to find the desired result. The array supports only for loop, for-each loop, while loop, do-while loop. ArrayList on the other hand supports the facility of iterators. We can use ListIterator to iterate through the ArrayList. ArrayList also supports loops, while arrays can never support iterators.<\/p>\n
8. Checking the Size:<\/strong> Both arrays and ArrayList have library functions to check their size. Arrays use the length object to check the length. Ar\u0325rayList uses the size() method to check the size. There is a difference here as well, the length object basically returns the total length of the array, it cannot calculate the amount of filled and empty spaces in the array. The size() method on the other hand returns the current capacity of the ArrayList.<\/p>\n
Example:<\/strong>
\n1.<\/p>\nint Arr[] = new int[100];\r\narrayLength = array.length; \/\/using the length object\r\n<\/pre>\n2.<\/p>\n
ArrayList ArrL = new ArrayList();\r\nArrL.add(21);\r\nArrL.size(); \/\/using the size() method\r\n<\/pre>\n9. Dimension:<\/strong> This is a very big difference between Arrays and ArrayList. In Array, we can create multidimensional arrays according to our needs. This helps us represent data of graphs, trees and other real-life objects at an ease. But, ArrayList does not have any such feature, Arraylists are a single dimension by default and it cannot be made multidimensional whatsoever. This is a very big drawback in ArrayList when it comes to data representation.<\/p>\n
Example of dimension in java:<\/strong><\/p>\n
Integer myArray[][] = new Integer[10][10]; \/\/multidimensional array of size 10x10\r\nmyArray[0][0] = new Integer(21);\r\n<\/pre>\n10. Type Safety:<\/strong> ArrayLists supports generics, thus ArrayList is Type-Safe, i.e, ArrayList allows the compiler to check the object for correctness. Array doesn\u2019t have any such provision, thus arrays are not type-safe. ArrayList supports compile-time checking whereas arrays support Runtime checking. Thus in an array, if the data is incorrect, it will give an ArrayStoreException at runtime.<\/p>\n
Example of type safety in java:<\/strong><\/p>\n
String stringArray[] = new String[100];\r\n\/\/ creates a string array of size 100\r\nstringArray[0] = new Integer(21);\r\n\/\/ throws ArrayStoreException, trying to add Integer object in String[], thus ensuring type safety.\r\n<\/pre>\n11. Supported Operations:<\/strong> To make the tasks of the programmer easier, ArrayList contains various methods that perform various important functions. Array lists support methods like get(), isEmpty(), indexOf(), replaceAll(), contains(), clear(), removeAll(), which makes programs a lot easier. Arrays on the other hand do not have these methods and everything has to be done manually, making array operations hard to perform.<\/p>\n
Array vs Arraylist in Java<\/h3>\n
\n\n
\n Property<\/b><\/td>\n Array<\/b><\/td>\n ArrayList<\/b><\/td>\n<\/tr>\n \n Definition<\/span><\/td>\n An array is a simple data structure with a contiguous memory location, in which data are stored with the same name but different index numbers. The data stored in an array must be of the same type. The size of an array is fixed after declaration.<\/span><\/td>\n ArrayList is a dynamic data structure that is part of the java collection framework. It also contains elements of the same type. Here we do not need to specify the size of the list.<\/span><\/td>\n<\/tr>\n \n Static\/Dynamic<\/span><\/td>\n Arrays are static<\/span><\/td>\n ArrayList is Dynamic<\/span><\/td>\n<\/tr>\n \n Resizable<\/span><\/td>\n Fixed Length<\/span><\/td>\n Resize Possible<\/span><\/td>\n<\/tr>\n \n Initialization\u00a0<\/span><\/td>\n It is mandatory to mention the size of an array during initialization<\/span><\/td>\n We do not need to mention the size in the case of ArrayList<\/span><\/td>\n<\/tr>\n \n Performance<\/span><\/td>\n Faster<\/span><\/td>\n Slower<\/span><\/td>\n<\/tr>\n \n Primitive\/Generic Type<\/span><\/td>\n An array can store objects and primitive data, but not generics.<\/span><\/td>\n ArrayList can store Objects and generics but cannot store primitive type data.<\/span><\/td>\n<\/tr>\n \n Iteration<\/span><\/td>\n Only Loops are allowed<\/span><\/td>\n Loops and iterators are allowed<\/span><\/td>\n<\/tr>\n \n Type-Safety<\/span><\/td>\n Not type-safe<\/span><\/td>\n It is type-safe<\/span><\/td>\n<\/tr>\n \n Length<\/span><\/td>\n Uses length object<\/span><\/td>\n Uses size() function<\/span><\/td>\n<\/tr>\n \n Adding Elements<\/span><\/td>\n It uses assignment operator for adding<\/span><\/td>\n It uses add() method<\/span><\/td>\n<\/tr>\n \n Single\/Multi-Dimensional<\/span><\/td>\n Both single and multidimensional possible<\/span><\/td>\n Only single dimensional allowed<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Example of Array and ArrayList using Java Programming<\/h3>\n
Now we will discuss a few programs to understand the differences properly.<\/p>\n
Code to Understand Array vs ArrayList Differences(Initialization and Access):<\/h4>\n
import java.util.Arrays;\r\npublic class arrVSarrL_Diff\r\n{\r\n public static void main(String args[]) {\r\n \/\/Creating and Initializing a Normal Array\r\n int[] arrN = new int[5];\r\n arrN[0] = 1;\r\n arrN[1] = 2;\r\n arrN[2] = 3;\r\n arrN[3] = 4;\r\n arrN[4] = 5;\r\n \/\/Accessing Array elements\r\n System.out.println(\"The first element of Array is: \" + arrN[0]);\r\n System.out.println(\"The second element of Array is: \" + arrN[1]); \r\n \/\/Creating an ArrayList with capacity 5 \r\n ArrayList < Integer > arrL = new ArrayList < Integer > (5);\r\n \/\/ Add elements to ArrayList \r\n arrL.add(1);\r\n arrL.add(2);\r\n arrL.add(3);\r\n arrL.add(4);\r\n arrL.add(5);\r\n \/\/ Accessing the elements of ArrayList \r\n System.out.println(\"The first element of ArrayList is: \" + arrL.get(0));\r\n System.out.println(\"The second element of ArrayList is: \" + arrL.get(1));\r\n }\r\n}\r\n<\/pre>\nThe output of the above code:<\/strong><\/p>\n
The first element of Array is: 1
\nThe second element of Array is: 2
\nThe first element of ArrayList is: 1
\nThe second element of ArrayList is: 2<\/div>\nCode to illustrate that arrays need to have a fixed declared size while ArrayList Doesn\u2019t:<\/h4>\n
package com.DataFlair.ArrayVsArrayList;\r\nimport java.util.ArrayList;\r\nimport java.util.Arrays;\r\npublic class Fixed_NotFixed\r\n{\r\n public static void main(String args[]) {\r\n \/\/Normal arrays in which we need to specify the size for array(here 5) \r\n int[] Arr = new int[5];\r\n Arr[0] = 1;\r\n Arr[1] = 2;\r\n Arr[2] = 3;\r\n Arr[3] = 4;\r\n Arr[4] = 5;\r\n System.out.println(\"Accessing array contents:\");\r\n System.out.println(Arrays.toString(Arr));\r\n \/* We cannot add more elements to array Arr as it is fixed size, otherwise we will get an error(ArrayIndexOutOfBound).*\/\r\n \/\/ArrayList we need not to specify size in ArrayList\r\n ArrayList < Integer > ArrL = new ArrayList < Integer > ();\r\n ArrL.add(1);\r\n ArrL.add(2);\r\n ArrL.add(3);\r\n ArrL.add(4);\r\n \/\/ We can add more elements to ArrL, as many as we want.\r\n System.out.println(\"Accessing ArrayList contents:\");\r\n System.out.println(ArrL);\r\n }\r\n}\r\n<\/pre>\nThe output of the above code:<\/strong><\/p>\n
![\"arraylist](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/05\/arraylist-error-when-primitive-data-used.webp\")
<\/a><\/p>\n