Method System.arraycopy()

The System.arraycopy() method in Java copies a portion of one array into another (or into the same array) faster and more reliably than a hand-written for loop. It is a static method declared in the java.lang.System class and implemented as native — its body is written not in Java but at the JVM level, which is where the speed advantage comes from.

Method Signature and Parameters

The method has a single signature and works with arrays of any type — both primitives and objects. This is exactly the contract described in the official Oracle documentation (the Javadoc of the java.lang.System class), which is the primary source for the method's behavior:

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

The method returns nothing (void) and does not create a new array — the destination dest must already exist and be long enough before the call.

Example: Copying Part of One Array into Another

Let's look at an example that copies elements 2, 3, and 4 from the arraySource into the arrayDestination array:

import java.util.Arrays;

public class ArrayCopyExample1 {
    public static void main(String[] args) {
        int[] arraySource = {1, 2, 3, 4, 5, 6};
        int[] arrayDestination = {0, 0, 0, 0, 0, 0, 0, 0};

        System.out.println("arraySource: " + Arrays.toString(arraySource));
        System.out.println("arrayDestination: " + Arrays.toString(arrayDestination));

        System.arraycopy(arraySource, 1, arrayDestination, 2, 3);
        System.out.println("arrayDestination after arrayCopy: " + Arrays.toString(arrayDestination));
    }
}

Output:

arraySource: [1, 2, 3, 4, 5, 6]
arrayDestination: [0, 0, 0, 0, 0, 0, 0, 0]
arrayDestination after arrayCopy: [0, 0, 2, 3, 4, 0, 0, 0]

The call System.arraycopy(arraySource, 1, arrayDestination, 2, 3) means: take 3 elements from arraySource starting at index 1 (the values 2, 3, 4) and write them into arrayDestination starting at index 2. The two arrays may have different lengths — the only requirement is that the specified range fits into both. The arrays are printed here with Arrays.toString().

Copying Within the Same Array with Overlapping Ranges

You can also copy elements within the same array, even when the source and destination ranges overlap. This is often useful for shifting values or other in-place array manipulation:

import java.util.Arrays;

public class ArrayCopyExample2 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8};
        System.out.println(Arrays.toString(array));

        System.arraycopy(array, 1, array, 3, 3);
        System.out.println(Arrays.toString(array));
    }
}

Output:

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

Exceptions: When arraycopy() Throws an Error

The method never resizes arrays and performs its own validation of the arguments, throwing an exception when something is off:

An ArrayIndexOutOfBoundsException example — length is larger than the destination can hold:

int[] src = {1, 2, 3};
int[] dest = new int[3];

try {
    System.arraycopy(src, 0, dest, 0, 5); // dest has no room for 5 elements
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Caught: " + e.getMessage());
}

A NullPointerException example — the destination was never initialized:

int[] src = {1, 2, 3};
int[] dest = null;

try {
    System.arraycopy(src, 0, dest, 0, 3);
} catch (NullPointerException e) {
    System.out.println("dest is null");
}

One subtle detail: if some elements have already been transferred by the time the exception is thrown, those changes in dest remain — the method does not roll back the part of the operation it has already completed.

System.arraycopy() vs Other Ways to Copy an Array

Choose System.arraycopy() when the destination already exists and you only need to copy part of the data into it (or shift elements inside a single array). When you need a brand-new array, Arrays.copyOf() or clone() is shorter and clearer — and both are built on top of arraycopy() anyway.

Keep in mind that for arrays of objects every one of these approaches performs a shallow copy: only the references are copied, not the objects themselves, so both arrays end up pointing to the same objects.

For more on arrays themselves, see the lessons “Array Declaration and Initialization”, “Multidimensional Arrays”, and “Array Length”.

Performance: Why arraycopy Beats a Loop

System.arraycopy() is declared native — the JVM performs the copy directly in memory (similar to low-level operations such as memmove), skipping the overhead of regular bytecode: per-iteration bounds checks, counter increments, method calls. That is why it is the standard choice inside the Java class library itself: Arrays.copyOf(), Arrays.copyOfRange(), and the internals of many collections are built on it, and it is widely used in performance-critical code such as data buffers.

On small arrays the difference from a manual loop is negligible, but on large volumes of data (tens of thousands of elements and more) System.arraycopy() and the methods built on it are noticeably faster — and, thanks to the correct handling of overlaps, safer than a home-grown loop.