Add Elements to Array in Java

In Java, arrays are basic data structures for storing elements of the same type in consecutive memory locations. Although arrays have a fixed size once they are created, there are different ways to add elements or create new arrays with new elements In this section, we will explore different ways adding elements to an array in Java.

An array is a collection of identical objects stored in consecutive locations in memory. The main advantage of an array is that we can randomly access the items in an array, whereas the elements in a linked list cannot be randomly moved.

In Java, Arrays are mutable data types, i.e., the size of the array is fixed, and we cannot directly add a new element in Array. However, there are various ways to add elements to the array.

Using ArrayList

Java's ArrayList is a dynamic array implementation that generates resizable arrays. It belongs to the Java Collections Framework and provides ways to add objects dynamically. Here's how we can use ArrayList to add elements to an array-like structure:

File Name: UsingArrayList.java

import java.util.ArrayList;
public class UsingArrayList {
    public static void main(String[] args) {
        // Create an ArrayList
        ArrayList<integer> arrayList = new ArrayList<>();
        // Add elements to the ArrayList
        arrayList.add(10);
        arrayList.add(20);
        arrayList.add(30); 
        // Convert ArrayList to array
        Integer[] array = arrayList.toArray(new Integer[0]);
        // Display the array
        for (Integer num : array) {
            System.out.println(num);
        }
    }
}
</integer>

Output:

10
20
30

Using Arrays.copyOf()

The arrays.copyOf() method in Java allows us to copy an existing array into a new array of specified length. We can add elements to the original array and assign additional lengths.

File Name: UsingArrayscopyOf.java

import java.util.Arrays;
public class UsingArrayscopyOf {
    public static void main(String[] args) {
        // Original array
        int[] originalArray = {1, 2, 3, 4, 5};
        // Copy array with additional elements
        int[] newArray = Arrays.copyOf(originalArray, originalArray.length + 3);   
        // Add elements to the new array
        newArray[originalArray.length] = 6;
        newArray[originalArray.length + 1] = 7;
        newArray[originalArray.length + 2] = 8;  
        // Display the new array
        for (int num : newArray) {
            System.out.println(num);
        }
    }
}

Output:

Using System.arraycopy() Method

The Java System.arraycopy() method is used to copy data from one array to another. We can use this method to create new layouts with additional features.

File Name: Systemarraycopy.java

public class Systemarraycopy{
    public static void main(String[] args) {
        // Original array
        int[] originalArray = {1, 2, 3, 4, 5};
        // Create a new array with additional elements
        int[] newArray = new int[originalArray.length + 3];      
        // Copy original array to the new array
        System.arraycopy(originalArray, 0, newArray, 0, originalArray.length);
        // Add elements to the new array
        newArray[originalArray.length] = 6;
        newArray[originalArray.length + 1] = 7;
        newArray[originalArray.length + 2] = 8;
        // Display the new array
        for (int num : newArray) {
            System.out.println(num);
        }
    }
}

Output:

Shifting elements to adjust the size of the array

In this method, we will add the elements to the specified index in the array. Likewise, the above two processes will use a new destination array with a larger size than the original array. However, it will be tricky to shift the destination array elements after copying all elements from the original array to destination array.

We will follow the steps given below to add element in the array:

Create a new destination array with a larger size than the original array.
Copy all the elements from the original array to the new destination array
Shift the elements after the given index to the right until it reaches the end of the array.
Insert the new element at the given index.

Consider the following example in which we will add a specific value at the given index 3 in the original array using a destination array.

File Name: JavaAddElementArraySpecified.java

import java.util.Arrays;  
public class JavaAddElementArraySpecified {  
public static void main(String[] args) {  
Integer arr[] = {1,2,3,4,5,6};  
int n = arr.length;  
int index = 3;  
System.out.println("Original Array: "+Arrays.toString(arr));  
Integer newArr[] = new Integer[n+1];  
int j = 0;  
for(int i = 0; i<newArr.length; i++) {  
if(i==index) {  
newArr[i] = 7;  
}else {  
newArr[i] = arr[j];  
j++;  
}  
}  
newArr[index] = 7;  
System.out.println("Array after adding value: "+Arrays.toString(newArr));  
}  
}  

Output:

Original Array: [1, 2, 3, 4, 5, 6]
Array after adding value: [1, 2, 3, 7, 4, 5, 6]

Conclusion

In Java, elements can be added to an array using various methods such as ArrayList, Arrays.copyOf(), and System.arraycopy(). The advantages of each option depend on the specific requirements of your application. Understanding these techniques allows us to manipulate arrays in Java programs.

Next TopicAdvantages and disadvantages of Java

← prev next →