How Do You Copy Arrays in Java?

There are four ways to do it, and only three of them copy anything. Assigning one array variable to another — int[] b = a; — copies the reference, not the data. Both names then point at the same array, so a write through one is visible through the other. It is the single most common array bug in Java, and it is why == on two array variables is usually a mistake in the first place.

The three genuine copies are Arrays.copyOf, the clone method on the array type, and System.arraycopy. All three allocate a new array and copy the elements into it, so the result is independent of the original for primitives.

import java.util.Arrays;

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

        // 1. The assignment: both names point at the same array.
        int[] same = original;
        same[0] = 99;
        System.out.println("after same[0]=99, original[0] = " + original[0]);

        // 2. A real copy.
        int[] copy = Arrays.copyOf(original, original.length);
        copy[0] = 7;
        System.out.println("after copy[0]=7, original[0]  = " + original[0]);

        // 3. A partial copy.
        int[] partial = Arrays.copyOf(original, 2);
        System.out.println("partial copy    : " + Arrays.toString(partial));

        // 4. clone() does the same job.
        int[] cloned = original.clone();
        cloned[1] = 50;
        System.out.println("after cloned[1]=50, original[1] = " + original[1]);
    }
}

The output is the clearest demonstration of the difference. After same[0] = 99 the original shows 99, because there is only one array. After copy[0] = 7 the original still shows 99, because the copy is a separate array. The partial copy holds the first two elements of the original as it stood at that moment, and the cloned array behaves exactly like the copy.

Two footnotes. clone on an array returns the array type, not Object, because the language special-cases it; and it performs a shallow copy, which matters as soon as the elements are objects rather than primitives.

Arrays.copyOf is the convenience method: it always creates a brand-new array of the length you ask for, copies as much of the source as fits, and pads the remainder with zeros. Arrays.copyOf(original, 7) on a five-element array gives you a seven-element array with the original five values followed by two zeros. Arrays.copyOf(original, 2) gives you a two-element array holding the first two values.

System.arraycopy is the lower-level primitive. It copies a range of elements from one array into an existing array, and you specify the source position, the destination position and the length. It never allocates the destination — you pass in an array you already have. That makes it the right tool when you are shifting elements within one array, filling a pre-allocated buffer, or copying between arrays of unrelated types.

import java.util.Arrays;

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

        // Arrays.copyOf: new array of the requested length, padded or truncated.
        int[] longer = Arrays.copyOf(source, 7);
        System.out.println("copyOf to 7  : " + Arrays.toString(longer));

        int[] shorter = Arrays.copyOf(source, 2);
        System.out.println("copyOf to 2  : " + Arrays.toString(shorter));

        // System.arraycopy: copy a range into an existing array.
        int[] target = new int[6];
        System.arraycopy(source, 1, target, 0, 3);
        System.out.println("arraycopy     : " + Arrays.toString(target));

        // Overlapping ranges are handled safely (like memmove).
        int[] overlap = {1, 2, 3, 4, 5};
        System.arraycopy(overlap, 0, overlap, 1, 4);
        System.out.println("overlapping   : " + Arrays.toString(overlap));
    }
}

The overlapping case is worth flagging. Copying within the same array — shifting elements left or right — is exactly what you need for removing or inserting an element in place, and System.arraycopy handles the overlap correctly, behaving like memmove rather than memcpy. A hand-written element-by-element loop gets that wrong in one direction.

For choosing between them: use Arrays.copyOf when you want a new array of a given size, and System.arraycopy when you are moving a range or filling a buffer you already allocated. If you find yourself reaching for System.arraycopy in ordinary application code, Arrays.copyOfRange usually expresses the intent better.

Because a primitive array holds the values themselves, while an object array holds references to objects that live elsewhere on the heap. Copying a primitive array copies the bits — a deep copy of the data by definition. Copying an object array copies the references, so the new array and the old one still point at the same objects.

That is what the term shallow copy means: one level of structure is duplicated, and everything below that level is shared. The array object is new; the elements inside it are the same elements.

The practical consequence is that mutating an element of the copy is visible through the original. If the array holds mutable objects — a StringBuilder, a Date, a domain entity — then copy[0].setName("x") changes the object that original[0] also points at. To get a truly independent copy you have to copy each element as well, which means either cloning each element or rebuilding the array from copies.

It also explains why the copy methods in the Collections Framework behave the way they do. new ArrayList<>(originalList) copies the references, so mutating an element of the new list is visible through the old one. The list-level copy constructors documented in the API are deliberately shallow for exactly this reason, and the copy-constructors on the element types are the ones that do the deep work.

The same rule applies to arrays of arrays. A 2D array is an array of arrays, so Arrays.copyOf(grid, grid.length) copies the row references and gives you a new outer array whose rows are the same row objects.