Java Copy Arrays

In this article, you will learn about different ways you can use to copy arrays (both one dimensional and two-dimensional) in Java.

There are several techniques you can use to copy arrays in Java.


1. Copying Arrays Using Assignment Operator

Let's take an example,

class CopyArray {
    public static void main(String[] args) {
       
        int [] numbers = {1, 2, 3, 4, 5, 6};
        int [] positiveNumbers = numbers;    // copying arrays

        for (int number: positiveNumbers) {
           System.out.print(number + ", ");
        }
    }
}

When you run the program, the output will be:

1, 2, 3, 4, 5, 6 

Though this technique to copy arrays seem to work perfectly, there is a problem with it.

If you change elements of one array in the above example, corresponding elements of the other array is also changed.

class AssignmentOperator {
   public static void main(String[] args) {
      
      int [] numbers = {1, 2, 3, 4, 5, 6};
      int [] positiveNumbers = numbers;    // copying arrays
      
      numbers[0] = -1;

      for (int number: positiveNumbers) {
         System.out.print(number + ", ");
      }
  }
}

When you run the program, the output will be:

-1, 2, 3, 4, 5, 6

When the first element of numbers array is changed to -1, the first element of positiveNumbers array also becomes -1. It's because both arrays refers to the same array object.

This is called shallow copy.

However, most often, we need deep copy rather than shallow copy. A deep copy copies the values creating the new array object.


2. Using Looping Construct to Copy Arrays

Let's take an example:

import java.util.Arrays;

class ArraysCopy {
   public static void main(String[] args) {
      
      int [] source = {1, 2, 3, 4, 5, 6};
      int [] destination = new int[6];

      for (int i = 0; i < source.length; ++i) {
         destination[i] = source[i];
      }
      
      // converting array to string
      System.out.println(Arrays.toString(destination));
  }
}

When you run the program, the output will be:

[1, 2, 3, 4, 5, 6]

Here, for loop is used to iterate through each element of source array. In each iteration, corresponding element of source array is copied to destination array.

The source and destination array doesn't share the same reference (deep copy). Meaning, if elements of one array (either source or destination) is changed, corresponding elements of another array is unchanged.

The toString() method is used to convert array to string (for the purpose of output only).


There is a better way (than using loops) to copy arrays in Java by using arraycopy() and copyOfRange() method.

3. Copying Arrays Using arraycopy() method

The System class contains arraycopy() method that allows you to copy data from one array to another.

The arraycopy() method is efficient as well as flexible. The method allows you to copy a specified portion of the source array to the destination array.

public static void arraycopy(Object src, int srcPos,
                      Object dest, int destPos, int length)

Here,

  • src - array you want to copy
  • srcPos - starting position (index) in the src array
  • dest - elements of src array will be copied to this array
  • destPos - starting position (index) in the dest array
  • length - number of elements to copy

Let's take an example:

// To use Arrays.toString() method
import java.util.Arrays;

class ArraysCopy {
   public static void main(String[] args) {
      int[] n1 = {2, 3, 12, 4, 12, -2};
      
      int[] n3 = new int[5];

      // Creating n2 array of having length of n1 array
      int[] n2 = new int[n1.length];
      
      // copying entire n1 array to n2
      System.arraycopy(n1, 0, n2, 0, n1.length);
      System.out.println("n2 = " + Arrays.toString(n2));  
      
      // copying elements from index 2 on n1 array
      // copying element to index 1 of n3 array
      // 2 elements will be copied
      System.arraycopy(n1, 2, n3, 1, 2);
      System.out.println("n3 = " + Arrays.toString(n3));  
  }
}

When you run the program, the output will be:

n2 = [2, 3, 12, 4, 12, -2]
n3 = [0, 12, 4, 0, 0]

Note, the default initial value of elements of an int type array is 0.


4. Copying Arrays Using copyOfRange() method

Additionally, you can use copyOfRange() method defined in java.util.Arrays class to copy arrays. You do not need to create the destination array before this method is called. Visit this page to learn more about copyOfRange() method.

Here's how you can do it.

// To use toString() and copyOfRange() method
import java.util.Arrays;

class ArraysCopy {
   public static void main(String[] args) {
      
      int[] source = {2, 3, 12, 4, 12, -2};
      
      // copying entire source array to destination
      int[] destination1 = Arrays.copyOfRange(source, 0, source.length);      
      System.out.println("destination1 = " + Arrays.toString(destination1)); 
      
      // copying from index 2 to 5 (5 is not included) 
      int[] destination2 = Arrays.copyOfRange(source, 2, 5); 
      System.out.println("destination2 = " + Arrays.toString(destination2));   
  }
}

When you run the program, the output will be:

destination1 = [2, 3, 12, 4, 12, -2]
destination2 = [12, 4, 12]

5. Copying 2d Arrays Using Loop

Here's an example to copy irregular 2d arrays using loop:

import java.util.Arrays;

class ArraysCopy {
public static void main(String[] args) {
      
      int[][] source = {
            {1, 2, 3, 4}, 
            {5, 6},
            {0, 2, 42, -4, 5}
            };

      int[][] destination = new int[source.length][];

      for (int i = 0; i < destination.length; ++i) {

         // allocating space for each row of destination array
         destination[i] = new int[source[i].length];

         for (int j = 0; j < destination[i].length; ++j) {
            destination[i][j] = source[i][j];
         }
      }
     
      // displaying destination array
      System.out.println(Arrays.deepToString(destination));  
      
  }
}

When you run the program, the output will be:

[[1, 2, 3, 4], [5, 6], [0, 2, 42, -4, 5]]

You can see we've used Arrays' deepToString() method here. deepToString() provides better representation of a multi-dimensional array as in a 2 dimensional array. Learn more about deepToString().


You can replace the inner loop of the above code with System.arraycopy() or Arrays.copyOf() array as in case of one-dimensional array.

Here's an example to do the same task with arraycopy() method.

import java.util.Arrays;

class AssignmentOperator {
public static void main(String[] args) {
      
      int[][] source = {
            {1, 2, 3, 4}, 
            {5, 6},
            {0, 2, 42, -4, 5}
            };

      int[][] destination = new int[source.length][];

      for (int i = 0; i < source.length; ++i) {

         // allocating space for each row of destination array
         destination[i] = new int[source[i].length];
         System.arraycopy(source[i], 0, destination[i], 0, destination[i].length);
      }
     
      // displaying destination array
      System.out.println(Arrays.deepToString(destination));      
  }
}