Increasing or Extending an Array Length in 3 ways

1. Overview

In this tutorial, We'll see how many ways an array can be extended in java.

The actual array values are stored in contiguous memory locations. The answer may not be promptly obvious.

if you are new to the Java Array, It is worthful to read the beginner articles.

How to create an array in java?

How to print an array in java?

How to add an element to an array in java?

2. Using Arrays.copyOf

First is Arrays.copyOf method. java.util.Arrays.copyOf() method is in java.util.Arrays class. It copies the specified array, truncating or padding with false (if necessary) so the copy has the specified length.

See the below model example.

Sample code snippet:

 /**
  * Adds the given elementToAdd value at the end of the given array. This method creates internally a new array.
  * 
  * @param srcArray
  * @param elementToAdd
  * @return
  */
 public Integer[] addElementUsingArraysCopyOf(Integer[] srcArray, int elementToAdd) {
  Integer[] destArray = Arrays.copyOf(srcArray, srcArray.length + 1);
  destArray[destArray.length - 1] = elementToAdd;
  return destArray;
 }

This method takes srcArray which is Integer[] array and an int value elementToAdd. This method returns a new array which a new value-added to it.
Internally copies all srcArray elements into a new array using copyOf method with size of srcArray.length+1. Here, array last index value added with value '0' and replacing with new value elementToAdd.

On this spot now, We should talk about a few cases on the below code.

 Integer[] destArray = Arrays.copyOf(srcArray, newLength);

If the newLength is greater than srcArray length then Arrays.copyOf() method will copy the extra null values into the destination array.

int[] srcArray = new int[] { 1, 2, 3, 4, 5, 6 };
int newLength = 10;
int[] destArray = Arrays.copyOf(srcArray, newLength);

Output:

input array : 1 2 3 4 5 6 
Destination array: 1 2 3 4 5 6 0 0 0 0 

Extra values filling behaviour will be changed based on the srcArray type. If it is Wrapper or custom classes array then null values will be added.
if srcArray is char then null values and if srcArray is a boolean array then false will be added. The Thumb rule is for extra value filling is with srcArray type default value.

In String class, concat() method uses copyof method internally in java api. And also uses System.arraycopy method inside concat method of String.

3. Using ArrayList

Second, we'll see using ArrayList. Here we do perform 3 steps.

1) covert srcArray to ArrayList
2) Add newElement to the ArrayList
3) Convert back ArrayList to destArray.

Sample code snippet:

 /**
  * Adds the given elementToAdd to Array using ArrayList internally.
  * @param srcArray
  * @param elementToAdd
  * @return
  */
 public Integer[] addElementUsingArrayList(Integer[] srcArray, int newElementToAdd) {
  Integer[] destArray = new Integer[srcArray.length + 1];
  List arrayList = new ArrayList<>(Arrays.asList(srcArray));
  arrayList.add(newElementToAdd);
  return arrayList.toArray(destArray);
 }

   
The above program is to add newElement to the array by increasing array size.

Invoking addElementUsingArrayList method.

int newElementToAdd = 7;
Integer[] srcArray = new Integer[] { 1, 2, 3, 4, 5, 6 };
Integer[] destArray = addElementUsingArrayList(srcArray, newElementToAdd);

New destArray values will be as below.   
   
Output:

New destArray values: 1 2 3 4 5 6 7 

We could see now that a new value-added to the array.

4. Using System.arraycopy

Finally, We'll take a look at System.arraycopy method which is heavily used in java API such as Collection and Arrays.

Syntax Structure:

void java.lang.System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

Sample code snippet:

 /**
  * Copies given elments into new array by adding elementToAdd using System.arraycopy method.
  * 
  * @param srcArray
  * @param elementToAdd
  * @return
  */
 public Integer[] addElementUsingSystemArrayCopy(Integer[] srcArray, int elementToAdd) {
  Integer[] destArray = new Integer[srcArray.length + 1];
  System.arraycopy(srcArray, 0, destArray, 0, srcArray.length);
  destArray[destArray.length - 1] = elementToAdd;
  return destArray;
 }

An interesting fact is that System.arraycopy method is used internally in Arrays.copyOf method and increasing the size of ArrayList when it reaches a threshold.

Here we can notice that we moved the elements from the srcArray to destArray and then add the new element to the destArray. But, still, the srcArray holds the original values and this is not modified.

5. Performance Aspect

In the above all discussed solutions, we had to create a new array using possible ways. The reason is that the array holds a contiguous block of memory for super-fast lookup, which is why we cannot simply resize it.

This operation impacts performance but ArrayList is well balanced in resizing the Array when it is actually needed. relation of memory is taken care by JVM.

6. Conclusion:

In this tutorial, we have explored the different ways of adding elements to the end of an array. In other words, increasing or extending the size of an Array.

All the example programs shown in this tutorial are on GitHub.