Dynamic Array in Java

An array is a fixed size, homogeneous data structure. The limitation of arrays is that they’re fixed in size. It means that we must specify the number of elements while declaring the array. Here a question arises that what if we want to insert an element and there is no more space is left for the new element? Here, the concept of dynamic array comes into existence. It expends the size of the array dynamically.

In this section, we will understand what is a dynamic array, features of the dynamic array, how to resize a dynamic array, and how to implement dynamic array in Java.

What is a dynamic array?

The dynamic array is a variable size list data structure. It grows automatically when we try to insert an element if there is no more space left for the new element. It allows us to add and remove elements. It allocates memory at run time using the heap. It can change its size during run time.

In Java, ArrayList is a resizable implementation. It implements the List interface and provides all methods related to the list operations. The strength of the dynamic array is:

Quick lookup
Variable size
Cache-friendly

Working of Dynamic Array

In the dynamic array, the elements are stored contiguously from the starting of the array and the remaining space remains unused. We can add the elements until the reserved spaced is completely consumed. When the reserved space is consumed and required to add some elements. In such a case, the fixed-sized array needs to be increased in size. Note that before appending the element, we allocate a bigger array, copy the elements from the array, and return the newly created array.

Another way to add an element is that first, create a function that creates a new array of double size, copies all the elements from the old array, and returns the new array. Similarly, we can also shrink the size of the dynamic array.

Size vs. Capacity

The initialization of a dynamic array creates a fixed-size array. In the following figure, the array implementation has 10 indices. We have added five elements to the array. Now, the underlying array has a length of five. Therefore, the length of the dynamic array size is 5 and its capacity is 10. The dynamic array keeps track of the endpoint.

Dynamic Array in Java

Features of Dynamic Array

In Java, the dynamic array has three key features: Add element, delete an element, and resize an array.

Add Element in a Dynamic Array

In the dynamic array, we can create a fixed-size array if we required to add some more elements in the array. Usually, it creates a new array of double size. After that, it copies all the elements to the newly created array. We use the following approach:

Dynamic Array in Java

Delete an Element from a Dynamic Array

If we want to remove an element from the array at the specified index, we use the removeAt(i) method. The method parses the index number of that element which we want to delete. After deleting the element, it shifts the remaining elements (elements that are right to the deleted element) to the left from the specified index number. We also use the remove() method that deletes an element from the end of the array. After shifting the elements, it stores 0 at the palace of the last element. Let’s understand it through an example, as we have shown in the following figure.

Dynamic Array in Java

Resizing a Dynamic Array in Java

We need to resize an array in two scenarios if:

The array uses extra memory than required.
The array occupies all the memory and we need to add elements.

In the first case, we use the srinkSize() method to resize the array. It reduces the size of the array. It free up the extra or unused memory. In the second case, we use the growSize() method to resize the array. It increases the size of the array.

It is an expensive operation because it requires a bigger array and copies all the elements from the previous array after that return the new array.

Dynamic Array in Java

Suppose in the above array, it is required to add six more elements and, in the array, no more memory is left to store elements. In such cases, we grow the array using the growSize() method.

Dynamic Array in Java

Initialize a Dynamic Array

The initialization of the dynamic array is the same as the static array. Consider the following Java program that initializes a dynamic array.

InitializeDynamicArray.java

  public class InitializeDynamicArray  {  public static void main(String[] args)   {  //declaring array  int array[];  //initialize an array  array= new int[6];  //adding elements to the array  array[0] = 34;  array[1] = 90;  array[2] = 12;  array[3] = 22;  array[4] = 9;  array[5] = 27;  System.out.print(“Elements of Array are: “);  //iteraton over the array  for(int i=0; i< array.length ; i++)   {  System.out.print(array[i] +” “);  }  }  }  

Output:

Elements of Array are: 34 90 12 22 9 27

Let’s implement the operations in a Java program that we have discussed above.

DynamicArrayExample1.java

  public class DynamicArrayExample1  {   private int array[];   private int count;   private int sizeofarray;   //creating a constructor of the class that initializes the values  public DynamicArrayExample1()   {   array = new int[1];   count = 0;   sizeofarray = 1;   }   //creating a function that appends an element at the end of the array  public void addElement(int a)   {   //compares if the number of elements is equal to the size of the array or not  if (count == sizeofarray)   {   //invoking the growSize() method that creates an array of double size      growSize();   }   //appens an element at the end of the array   array[count] = a;   count++;   }   //function that creates an array of double size  public void growSize()   {   //declares a temp[] array      int temp[] = null;   if (count == sizeofarray)   {   //initialize a double size array of array  temp = new int[sizeofarray * 2];   {   for (int i = 0; i < sizeofarray; i++)   {   //copies all the elements of the old array  temp[i] = array[i];   }   }   }   array = temp;   sizeofarray= sizeofarray * 2;   }   //creating a function that deletes an element at the specified index  public void addElementAt(int index, int a)   {   //compare the size with the number of elements if not equal grows the array size  if (count == sizeofarray)   {   //invoking growSize() method  growSize();   }   for (int i = count – 1; i >= index; i–)   {   //shifting all the elements to the left from the specified index  array[i + 1] = array[i];   }   //inserts an element at the specified index  array[index] = a;   count++;   }   public static void main(String[] args)   {   DynamicArrayExample1 da = new DynamicArrayExample1();   //adding elements to the array  da.addElement(12);   da.addElement(22);   da.addElement(35);   da.addElement(47);   da.addElement(85);   da.addElement(26);   da.addElement(70);   da.addElement(81);   da.addElement(96);   da.addElement(54);  System.out.println(“Elements of the array:”);   //iterate over the array for accessing the elements  for (int i = 0; i < da.sizeofarray; i++)   {   System.out.print(da.array[i] + ” “);   }   System.out.println();   //determines and prints the size and number of elements of the array  System.out.println(“Size of the array: ” + da.sizeofarray);   System.out.println(“No. of elements in the array: ” + da.count);  //invoking the method to add an element at the specified index  da.addElementAt(5, 99); //where 5 is the index number and 99 is the element to be add  System.out.println(“nElements of the array after adding an element at index 5:”);   //iterate over the array for accessing the elements after adding the element at index 5  for (int i = 0; i < da.sizeofarray; i++)   {   System.out.print(da.array[i] + ” “);   }   System.out.println();   //determines and prints the size and number of elements of the array  System.out.println(“Size of the array: ” + da.sizeofarray);   System.out.println(“No. of elements in the array: ” + da.count);   }  }  

Output:

Dynamic Array in Java

Let’s shrink the array, delete the last element, and a specified element from the array.

DynamicArrayExample2.java

  public class DynamicArrayExample2  {   private int array[];   private int count;   private int sizeofarray;   //creating a constructor of the class that initializes the values  public DynamicArrayExample2()   {   array = new int[1];   count = 0;   sizeofarray = 1;   }   //creating a function that appends an element at the end of the array  public void addElement(int a)   {   //compares if the number of elements is equal to the size of the array or not  if (count == sizeofarray)   {   //invoking the growSize() method that creates an array of double size      growSize();   }   //appens an element at the end of the array   array[count] = a;   count++;   }   //function that creates an array of double size  public void growSize()   {   //declares a temp[] array      int temp[] = null;   if (count == sizeofarray)   {   //initialize a double size array of array  temp = new int[sizeofarray * 2];   {   for (int i = 0; i < sizeofarray; i++)   {   //copies all the elements of the old array  temp[i] = array[i];   }   }   }   array = temp;   sizeofarray= sizeofarray * 2;   }   //the method removes the unused space  public void shrinkSize()   {   //declares a temp[] array      int temp[] = null;   if (count > 0)   {   //creates an array of the size equal to the count i.e. number of elements the array have  temp = new int[count];   for (int i = 0; i < count; i++)   {   //copies all the elements of the old array  temp[i] = array[i];   }   sizeofarray = count;   array = temp;   }   }   //creating a function that removes the last elements for the array  public void removeElement()   {   if (count > 0)   {   array[count – 1] = 0;   count–;   }   }   //creating a function that delets an element from the specified index  public void removeElementAt(int index)   {   if (count > 0)   {   for (int i = index; i < count – 1; i++)   {   //shifting all the elements to the left from the specified index  array[i] = array[i + 1];   }   array[count – 1] = 0;   count–;   }   }   public static void main(String[] args)   {   DynamicArrayExample2 da = new DynamicArrayExample2();   //adding elements to the array  da.addElement(12);   da.addElement(22);   da.addElement(35);   da.addElement(47);   da.addElement(85);   da.addElement(26);   da.addElement(70);   da.addElement(81);   da.addElement(96);   da.addElement(54);  System.out.println(“Elements of the array:”);   //iterate over the array for accessing the elements  for (int i = 0; i < da.sizeofarray; i++)   {   System.out.print(da.array[i] + ” “);   }   System.out.println();   //determines and prints the size and number of elements of the array  System.out.println(“Size of the array: ” + da.sizeofarray);   System.out.println(“No. of elements in the array: ” + da.count);   //invoking the method to delete the last element of the array  da.removeElement();   //prints array after deleting the last element  System.out.print(“nElements of the array after deleting the last element: “);   for (int i = 0; i < da.sizeofarray; i++)  {   System.out.print(da.array[i] + ” “);   }   System.out.println();   //determines and prints the size and number of elements of the array  System.out.println(“Size of the array: ” + da.sizeofarray);   System.out.print(“No. of elements in the array: ” + da.count+”n”);   //invoking the method that deletes an element from the specified index  da.removeElementAt(7);   System.out.print(“nElements of the array after deleting the element at index 7: “);   //prints the array after deleting the element from index 7  for (int i = 0; i < da.sizeofarray; i++)   {   System.out.print(da.array[i] + ” “);   }   System.out.println();   //determines and prints the size and number of elements of the array  System.out.println(“Size of the array: ” + da.sizeofarray);   System.out.print(“No. of elements in the array: ” + da.count);   }   }  

Output:

Dynamic Array in Java

Next TopicShunting yard algorithm

Dynamic Array in Java

Dynamic Array in Java

What is a dynamic array?

Working of Dynamic Array

Size vs. Capacity

Features of Dynamic Array

Add Element in a Dynamic Array

Delete an Element from a Dynamic Array

Resizing a Dynamic Array in Java

Initialize a Dynamic Array

Convert List to Array in Java

Java Garbage Collection

You may also like