Array Copy in Java
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.
Example:
Assigning one array to another is an incorrect approach to copying arrays. It only creates a reference to the original array. If any changes are made to one array, it will reflect in the other since they both point to the same memory location.
// Java Program to demonstrate that assigning
// one array reference to another
// is incorrect for copying
public class Test {
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];
// Incorrectly attempt to copy by assigning a to b
// it makes b refer to the same array as a
b = a;
// Change to b[] will also reflect in a[]
// as a and b refer to same array in memory
b[0]++;
System.out.println("Contents of a[] ");
for (int i = 0; i < a.length; i++)
System.out.print(a[i] + " ");
System.out.println("\n\nContents of b[] ");
for (int i = 0; i < b.length; i++)
System.out.print(b[i] + " ");
}
}
Output
Contents of a[] 2 8 3 Contents of b[] 2 8 3
Table of Content
Methods to Copy Array 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 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.
// Java program to demonstrate Copying of Array
// using clone() method
public class GFG {
public static void main(String[] args) {
int a[] = { 1, 8, 3 };
// Copying elements of a[] to b[]
int b[] = a.clone();
// 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: This example uses the clone() method to copy “a" into “b". After incrementing b[0], we see that only “b" changes, while “a" stays the same.
Using arraycopy() method
We can also use System.arraycopy() Method. The system is present in java.lang package. Its signature is as follows:
// 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 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 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 arrayb[].- Since
b[]is a separate copy of the specified range froma[], modifyingb[]does not affecta[]. - The output will confirm that changes in
b[]do not alter the original arraya[].\
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.
