Dynamic Array in Java

Introduction to Dynamic Array in Java

Dynamic Array in Java means either stretched or shrank the size of the array depending upon user requirements. While an element is removed from an array, the array size must be shrunken, and if an element is added to an array, then the array size becomes stretch. Arrays are used to store homogenous elements means the same type of elements can be stored at a time.

Declaration of Dynamic Array in Java

Example: We can store integer numbers, float numbers, double numbers, strings, characters, Objects, etc. but at a time and any specific type only.

An array can be declared in 3 ways:

1. Array[]

Example:

int Array[]={1,2,4};

2. [] Array

Example:

int[] Array ={1,2,4};

3. []A

Example:

int []Array ={1,2,4};

How are Array Elements Iterated?

Array elements are iterated by using:

• For loop
• While loop
• For Each loop

Is there any other alternative way to make the array become dynamic?

• Yes, by using Java collections, we can achieve this.
• For a dynamic array, we can use the ArrayList class.
• Arraylist size can be automatically increased or decreased based on user action.

What is the advantage over the normal dynamic array to collections Arraylist?

• Based on user requirement, array size can be increased (stretched) or decreased(shrink) in, but in arrays first, we must make normal array to dynamic array by writing custom code for add elements, remove elements, etc.
• Inside Arraylist implementation is on arrays concept only.

How does Dynamic Array work in Java?

• To make a normal array to a dynamic array, we must write custom logic for adding, removing elements, increasing and decreasing size and capacity, etc.

Syntax:

class DynamicArray
{
addingElements()
{
//custom logic
}
addingElementsAtIndex(int index, int element)
{
//custom logic
}
removingElements()
{
//custom logic
}
removingElementsAtIndex(int index, int element)
{
//custom logic
}
increasingSize()
{
//custom logic
}
decreasingSize()
{
//custom logic
}
printArrayElements()
{
//custom logic
}
.
.
.
}

• In the ArrayList collection, there is no need to write custom logic. It will provide all custom methods for adding, removing elements, get size and capacity, get elements based on the index, removing elements based on the index, etc.

Syntax:

class ArrayListLogic
{
List<Generic Type> list=new ArrayList<Generic Type>();
list.add();
list.remove(index,element);
.
.
.
}

Examples of Dynamic Array in Java

Given below are the examples of Dynamic Array in Java:

Example #1

Adding the elements to the array and increasing size and capacity dynamically.

Code:

package com.dynamicarray;
import java.util.Arrays;
public class DynamicArray {
// declaring an array
int myArray[];
// stores the present size of the array
int sizeOfMyArray;
// stores total capacity of an array
int arrayCapacity;
// initializing array, size and capacity
public DynamicArray() {
myArray = new int[2];
sizeOfMyArray = 0;
arrayCapacity = 2;
}
// method for adding elements
public void addElementsToArray(int element) {
// makes the capacity double if all the array elements filled
if (sizeOfMyArray == arrayCapacity) {
increaseCapacity(2);
}
myArray[sizeOfMyArray] = element;
sizeOfMyArray++;
}
// method for adding elements to specific position
public void addElementAtPosition(int position, int value) {
// makes the capacity double if all the array elements filled
if (sizeOfMyArray == arrayCapacity) {
increaseCapacity(2);
}
// shifting array elements
for (int p = sizeOfMyArray - 1; p >= position; p--) {
myArray[p + 1] = myArray[p];
}
// adding the element at specific position
myArray[position] = value;
sizeOfMyArray++;
}
// method for getting the element from specific position
public int getElementAtposition(int position) {
return myArray[position];
}
// method for increasing capacity if all the elements in an array filled
public void increaseCapacity(int minimumCapacity) {
int temp[] = new int[arrayCapacity * minimumCapacity];
for (int p = 0; p < arrayCapacity; p++) {
temp[p] = myArray[p];
}
myArray = temp;
arrayCapacity = arrayCapacity * minimumCapacity;
}
// method for array current size
public int displaySize() {
return sizeOfMyArray;
}
// method for array total capacity
public int displayCapacity() {
return arrayCapacity;
}
// method for display all elements
public void displayArrayElements() {
System.out.println("elements in array are :" + Arrays.toString(myArray));
}
public static void main(String[] args) {
DynamicArray array = new DynamicArray();
System.out.println("===================================================================");
System.out.println("Inital array size " + array.displaySize() + " and initial capacity " + array.displayCapacity());
System.out.println("===================================================================");
// adding elements at index 0 and 1
array.addElementsToArray(10);//line 1
array.addElementsToArray(20);//line 2
System.out.println("Size of myArray =>" + array.displaySize() + " and Capacity :" + array.displayCapacity());
array.addElementsToArray(30); //line 3
System.out.println("Size of myArray =>" + array.displaySize() + " and Capacity :" + array.displayCapacity());
array.displayArrayElements(); //line 4
// adding element at index 1
array.addElementAtPosition(1, 50);
System.out.println("Size of myArray =>" + array.displaySize() + " and Capacity :" + array.displayCapacity());
array.displayArrayElements();
// adding element at index 2
array.addElementAtPosition(2, 60);
System.out.println("Size of myArray =>" + array.displaySize() + " and Capacity :" + array.displayCapacity());
array.displayArrayElements();
}
}

Output:

Explanation:

• In line 1 and line 2 added 2 elements; after that, we are trying to add one more element in line 3, but the initial capacity of an array is 2 only.
• When we try to insert the third element, the array capacity increases to 4 (as we specify capacity=2*initial size).
• So, we can be able to add the 3^rd element also.
• Line 4 displayed all the array elements.

Example #2

• Removing the elements from an array and reducing size and capacity dynamically.
• This example is the continuation of the above example.

Code:

package com.dynamicarray;
import java.util.Arrays;
public class DynamicArray {
// declaring an array
int myArray[];
// stores the present size of the array
int sizeOfMyArray;
// stores total capacity of an array
int arrayCapacity;
// initializing array, size and capacity
public DynamicArray() {
myArray = new int[2];
sizeOfMyArray = 0;
arrayCapacity = 2;
}
// method for adding elements
public void addElementsToArray(int element) {
// makes the capacity double if all the array elements filled
if (sizeOfMyArray == arrayCapacity) {
increaseCapacity(2);
}
myArray[sizeOfMyArray] = element;
sizeOfMyArray++;
}
// method for adding elements to specific position
public void addElementAtPosition(int position, int value) {
// makes the capacity double if all the array elements filled
if (sizeOfMyArray == arrayCapacity) {
increaseCapacity(2);
}
// shifting array elements
for (int p = sizeOfMyArray - 1; p >= position; p--) {
myArray[p + 1] = myArray[p];
}
// adding the element at specific position
myArray[position] = value;
sizeOfMyArray++;
}
// method for getting the element from specific position
public int getElementAtposition(int position) {
return myArray[position];
}
// method for removing elements
public void removeAtPosition(int position) {
if (position >= sizeOfMyArray || position < 0) {
System.out.println("Opps!No elements found " + position + " position");
} else {
for (int p = position; p < sizeOfMyArray - 1; p++) {
myArray[p] = myArray[p + 1];
}
myArray[sizeOfMyArray - 1] = 0;
sizeOfMyArray--;
}
}
// method for increasing capacity if all the elements in an array filled
public void increaseCapacity(int minimumCapacity) {
int temp[] = new int[arrayCapacity * minimumCapacity];
for (int p = 0; p < arrayCapacity; p++) {
temp[p] = myArray[p];
}
myArray = temp;
arrayCapacity = arrayCapacity * minimumCapacity;
}
// method for make an array size to initial size
public void makeInitialSize() {
System.out.println("Making an array to initial size");
int temp[] = new int[sizeOfMyArray];
for (int q = 0; q < sizeOfMyArray; q++) {
temp[q] = myArray[q];
}
myArray = temp;
arrayCapacity = myArray.length;
}
// method for array current size
public int displaySize() {
return sizeOfMyArray;
}
// method for array total capacity
public int displayCapacity() {
return arrayCapacity;
}
// method for display all elements
public void displayArrayElements() {
System.out.println("elements in array are :" + Arrays.toString(myArray));
}
public static void main(String[] args) {
DynamicArray array = new DynamicArray();
System.out.println("===================================================================");
System.out.println("Inital array size " + array.sizeOfMyArray + " and initial capacity " + array.arrayCapacity);
System.out.println("===================================================================");
array.addElementsToArray(10);
array.addElementsToArray(20);
array.addElementsToArray(30);
array.addElementsToArray(40);
array.displayArrayElements();
array.removeAtPosition(2);
System.out.println("Size after Remove Operation=>" + array.displaySize() + " and Capacity :"
+ array.displayCapacity());
array.displayArrayElements();
array.removeAtPosition(2);
System.out.println("Size after Remove Operation=>" + array.displaySize() + " and Capacity :"
+ array.displayCapacity());
array.displayArrayElements();
array.removeAtPosition(1);
System.out.println("Size after Remove Operation=>" + array.displaySize() + " and Capacity :"
+ array.displayCapacity());
array.displayArrayElements();
array.removeAtPosition(2);
System.out.println("Size after Remove Operation =>" + array.displaySize() + " and Capacity :"
+ array.displayCapacity());
array.displayArrayElements();
array.removeAtPosition(1);
System.out.println("Size after Remove Operation =>" + array.displaySize() + " and Capacity :"
+ array.displayCapacity());
array.displayArrayElements();
// Make the array to initial size
array.makeInitialSize();
System.out.println(" After trimming Size of myArray =>" + array.displaySize() + " and Capacity :"
+ array.displayCapacity());
array.displayArrayElements();
array.addElementsToArray(-5);
System.out.println("After trimming Size of myArray =>" + array.displaySize() + " and Capacity :"
+ array.displayCapacity());
array.displayArrayElements();
array.addElementsToArray(-6);
System.out.println("After trimming Size of myArray =>" + array.displaySize() + " and Capacity :"
+ array.displayCapacity());
array.displayArrayElements();
}
}

Output:

Example #3

Dynamic array with ArrayList.

Code:

package com.dynamicarray;
import java.util.ArrayList;
import java.util.List;
public class ArrayListDynamic {
public static void main(String[] args) {
List<Integer> list=new ArrayList<Integer>();
list.add(10);
list.add(20);
list.add(30);
list.add(40);
System.out.println("Adding the elements ArrayList =>"+list);
System.out.println("Adding the elements ArrayList size =>"+list.size());
/*Array List capacity formula newCapacity = (oldCapacity * 3/2) + 1*/
list.add(4, 50);
System.out.println("After adding the element at specific index =>"+list+" and size "+list.size());
list.remove(4);
list.remove(3);
System.out.println("After removing the elements =>"+list+" and size "+list.size());
}
}

Output:

Conclusion

In a normal dynamic array, the implementation developer must write custom logic, whereas, in collection ArrayList, all predefined methods are available, so no need to write custom logic.

This is a guide to Dynamic Array in Java. Here we discuss the introduction, examples, and how does dynamic array work in Java? You may also have a look at the following articles to learn more –

1. Java Array Iterator
2. Arrays in Java Programming
3. do-while loop in Java
4. Arrays Methods in JavaScript