Open In App

Array Copy in Java

Last Updated : 23 Jul, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

In Java, copying an array can be done in several ways, depending on our needs such as shallow copy or deep copy. In this article, we will learn different methods to copy arrays in Java.

Copying Each Element Individually

Iterating each element of the given original array and copy one element at a time. With the usage of this method, it guarantees that any modifications to "b", will not alter the original array "a", as shown in below example.

Java 
// Java program to demonstrate copying
// copying an array by assigning 
// elements one by one
public class GFG {

    public static void main(String[] args) {
        
        int a[] = { 1, 8, 3 };

        // Create an array b[] of same size as a[]
        int b[] = new int[a.length];

        // Copying elements of a[] to b[]
        for (int i = 0; i < a.length; i++)
            b[i] = a[i];

        // Changing b[] to verify that
        // b[] is different from a[]
        b[0]++;

        System.out.println("");

        for (int i = 0; i < a.length; i++)
            System.out.print(a[i] + " ");

        System.out.println("");

        for (int i = 0; i < b.length; i++)
            System.out.print(b[i] + " ");
    }
}

Output
1 8 3 
2 8 3

Explanation: In this example, after copying, the first element of b (b[0]++) is incremented, so b[0] becomes 2, but a[0] remains 1.

Using clone() method 

In the previous method, we had to iterate over the entire array to make a copy. A more efficient approach is to use the clone() method in Java. This method provides a quick way to create a shallow copy of an array without manual iteration.

1. Cloning of Single-Dimensional Array

When you clone a single-dimensional array, such as Object[], a shallow copy is performed.

Clone-of-Array-660
Java 
class Geeks {
    public static void main(String args[])
    {
        int intArray[] = { 1, 2, 3 };

        int cloneArray[] = intArray.clone();

        // will print false as shallow copy is created
        System.out.println(intArray == cloneArray);

        for (int i = 0; i < cloneArray.length; i++) {
            System.out.print(cloneArray[i] + " ");
        }
    }
}

Output
false
1 2 3

Explanation:

  • This program demonstrates cloning a one-dimensional array using the clone() method, which creates a shallow copy.
  • The original and cloned arrays have the same contents but are different objects in memory (intArray == cloneArray returns false).

2. Cloning Multidimensional Array

A clone of a multi-dimensional array (like Object[][]) is a "shallow copy,"

Multidimensional-Array-Clone-660
Java 
// Java program to demonstrate
// cloning of multi-dimensional arrays

class Geeks {
    public static void main(String args[])
    {
        int intArray[][] = { { 1, 2, 3 }, { 4, 5 } };

        int cloneArray[][] = intArray.clone();

        // will print false
        System.out.println(intArray == cloneArray);

        // will print true as shallow copy is created
        // i.e. sub-arrays are shared
        System.out.println(intArray[0] == cloneArray[0]);
        System.out.println(intArray[1] == cloneArray[1]);
    }
}

Output
false
true
true

Explanation:

This program shows that cloning a multi-dimensional array creates a shallow copy—the top-level array is duplicated, but inner arrays are still shared references.

Using arraycopy() method

We can also use System.arraycopy() Method. The system is present in java.lang package. Its signature is as follows: 

Java 
// Java program to demonstrate array
// copy using System.arraycopy()
public class GFG {

    public static void main(String[] args) {
      
        int a[] = { 1, 8, 3 };

        // Creating an array b[] of same size as a[]
        int b[] = new int[a.length];

        // Copying elements of a[] to b[]
        System.arraycopy(a, 0, b, 0, 3);

        // Changing b[] to verify that
        // b[] is different from a[]
        b[0]++;

        System.out.println("");

        for (int i = 0; i < a.length; i++)
            System.out.print(a[i] + " ");

        System.out.println("");

        for (int i = 0; i < b.length; i++)
            System.out.print(b[i] + " ");
    }
}

Output
1 8 3 
2 8 3

Explanation: After copying with System.arraycopy(), the first element of "b" is incremented, so b[0] becomes 2, but a[0] remains 1.

Using copyOf() method of Arrays class 

We can use Arrays.copyOf() method, if we want to copy the first few elements of an array or make a full copy of the array, we can use this method.

Java 
// Java program to demonstrate array
// copy using Arrays.copyOf()
import java.util.Arrays;

class GFG {

    public static void main(String[] args) {
       
        int a[] = { 1, 8, 3 };

        // Create an array b[] of same size as a[]
        // Copy elements of a[] to b[]
        int b[] = Arrays.copyOf(a, 3);

        // Change b[] to verify that
        // b[] is different from a[]
        b[0]++;

        System.out.println("");

        // Iterating over array a[]
        for (int i = 0; i < a.length; i++)
            System.out.print(a[i] + " ");

        System.out.println("");

        // Iterating over array b[]
        for (int i = 0; i < b.length; i++)
            System.out.print(b[i] + " ");
    }
}

Output
1 8 3 
2 8 3

Explanation: The Arrays.copyOf() method copies the elements of "a" to "b". After modifying b[0], we see that only "b" is affected.

Using copyOfRange() method of Arrays class

The Arrays.copyOfRange() method copies the specified range of the specified array into a new array.

Note: The range is specified by the indices [from, to), meaning the element at the from index is included, but the element at the to index is not.

Example:

Java 
// Java program to demonstrate array 
// copy using Arrays.copyOfRange() 
import java.util.Arrays; 
 
class GFG { 

    public static void main(String[] args) { 
      
        int a[] = { 1, 8, 3, 5, 9, 10 }; 

        // Creating an array b[] and 
        // copying elements of a[] to b[] 
        int b[] = Arrays.copyOfRange(a, 2, 6); 

        // Changing b[] to verify that 
        // b[] is different from a[] 
        b[0]++;  // Modify b[0] to check if it affects a[]

        // Iterating over array a[] 
        System.out.println(""); 
        for (int i = 0; i < a.length; i++) 
            System.out.print(a[i] + " "); 

        // Iterating over array b[] 
        System.out.println(""); 
        for (int i = 0; i < b.length; i++) 
            System.out.print(b[i] + " "); 
    } 
}

Output
1 8 3 5 9 10 
4 5 9 10

Explanation:

  • b[0]++ increments the first element of array b[].
  • Since b[] is a separate copy of the specified range from a[], modifying b[] does not affect a[].
  • The output will confirm that changes in b[] do not alter the original array a[].

Shallow Copy Vs Deep Copy

  • Shallow Copy: It copies only the reference of nested objects, not the actual data. Making changes to nested objects affect both the original and the copy.
  • Deep Copy: It creates a full, independent copy of the object, including nested objects. Making any changes to the copy do not affect the original object.

K

kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox