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.

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:

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.

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.

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.

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:

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: