Performance of System.arraycopy() vs. Arrays.copyOf()

1. Introduction

In this tutorial, we will look at the performance of two Java methods: System.arraycopy() and Arrays.copyOf(). First, we'll analyze their implementations. Second, we'll run some benchmarks to compare their average execution times.

2. Performance of System.arraycopy()

System.arraycopy() copies the array contents from the source array, beginning at the specified position, to the designated position in the destination array. Additionally, before copying, the JVM checks that both source and destination types are the same.

When estimating the performance of System.arraycopy(), we need to keep in mind that it is a native method. Native methods are implemented in platform-dependent code (typically C) and accessed through JNI calls.

Because native methods are already compiled for a specific architecture, we can't precisely estimate the runtime complexity. Moreover, their complexities can differ between platforms. We can be sure that the worst-case scenario is O(N). However, the processor can copy contiguous blocks of memory one block at a time (memcpy() in C), so actual results can be better.

We can view only the signature of System.arraycopy():

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

3. Performance of Arrays.copyOf()

Arrays.copyOf() offers additional functionality on top of what System.arraycopy() implements. While System.arraycopy() simply copies values from the source array to the destination, Arrays.copyOf() also creates new array. If necessary, it will truncate or pad the content.

The second difference is that the new array can be of a different type than the source array. If that's the case, the JVM will use reflection, which adds performance overhead.

When called with an Object array, copyOf() will invoke the reflective Array.newInstance() method:

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
    T[] copy = ((Object)newType == (Object)Object[].class) 
      ? (T[]) new Object[newLength]
      : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
    return copy;
}

However, when invoked with primitives as parameters, it doesn't need reflection to create a destination array:

public static int[] copyOf(int[] original, int newLength) {
    int[] copy = new int[newLength];
    System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
    return copy;
}

We can clearly see that currently, the implementation of Arrays.copyOf() calls System.arraycopy(). As a result, runtime execution should be similar. To confirm our suspicion, we will benchmark the above methods with both primitives and objects as parameters.

4. Code Benchmark

Let's check which copy method is faster with the real test. To do that, we'll use JMH (Java Microbenchmark Harness). We'll create a simple test in which we will copy values from one array to the other using both System.arraycopy() and Arrays.copyOf().

We'll create two test classes. In one test class, we will test primitives, and in the second, we'll test objects. The benchmark configuration will be the same in both cases.

4.1. Benchmark Configuration

First, let's define our benchmark parameters:

@BenchmarkMode(Mode.AverageTime)
@State(Scope.Thread)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 10)
@Fork(1)
@Measurement(iterations = 100)

Here, we specify that we want to run our benchmark only once, with 10 warmup iterations and 100 measurement iterations.  Moreover, we would like to calculate the average execution time and collect the results in nanoseconds. To obtain exact results, it is important to perform at least five warmup iterations.

4.2. Parameters Setup

We need to be sure that we measure only the time spent on method execution and not on array creation. To do that, we'll initialize the source array in the benchmark setup phase. It's a good idea to run the benchmark with both big and small numbers.

In the setup method, we simply initialize an array with random parameters. First, we define the benchmark setup for primitives:

public class PrimitivesCopyBenchmark {
    @Param({ "10", "1000000" })
    public int SIZE;
    int[] src;
    @Setup
    public void setup() {
        Random r = new Random();
        src= new int[SIZE];
        for (int i = 0; i < SIZE; i++) {
            src[i] = r.nextInt();
        }
    }
}

The same setup follows for the objects benchmark:

public class ObjectsCopyBenchmark {
    @Param({ "10", "1000000" })
    public int SIZE;
    Integer[] src;
    @Setup
    public void setup() {
        Random r = new Random();
        src= new Integer[SIZE];
        for (int i = 0; i < SIZE; i++) {
            src[i] = r.nextInt();
        }
    }
}

4.3. Tests

We define two benchmarks that will execute copy operations. First, we'll call System.arraycopy():

@Benchmark
public Integer[] systemArrayCopyBenchmark() {
    Integer[] target = new Integer[SIZE];
    System.arraycopy(src, 0, target, 0, SIZE);
    return target;
}

To make both tests equivalent, we've included target array creation in the benchmark.

Second, we'll measure the performance of Arrays.copyOf():

@Benchmark
public Integer[] arraysCopyOfBenchmark() {
    return Arrays.copyOf(src, SIZE);
}

4.4. Results

After running our test, let's look at the results:

Benchmark                                          (SIZE)  Mode  Cnt        Score       Error  Units
ObjectsCopyBenchmark.arraysCopyOfBenchmark             10  avgt  100        8.535 ±     0.006  ns/op
ObjectsCopyBenchmark.arraysCopyOfBenchmark        1000000  avgt  100  2831316.981 ± 15956.082  ns/op
ObjectsCopyBenchmark.systemArrayCopyBenchmark          10  avgt  100        9.278 ±     0.005  ns/op
ObjectsCopyBenchmark.systemArrayCopyBenchmark     1000000  avgt  100  2826917.513 ± 15585.400  ns/op
PrimitivesCopyBenchmark.arraysCopyOfBenchmark          10  avgt  100        9.172 ±     0.008  ns/op
PrimitivesCopyBenchmark.arraysCopyOfBenchmark     1000000  avgt  100   476395.127 ±   310.189  ns/op
PrimitivesCopyBenchmark.systemArrayCopyBenchmark       10  avgt  100        8.952 ±     0.004  ns/op
PrimitivesCopyBenchmark.systemArrayCopyBenchmark  1000000  avgt  100   475088.291 ±   726.416  ns/op

As we can see, the performance of System.arraycopy() and Arrays.copyOf() differs on the range of measurement error for both primitives and Integer objects. It isn't surprising, considering the fact that Arrays.copyOf() uses System.arraycopy() under the hood. Since we used two primitive int arrays, no reflective calls were made.

We need to remember that JMH gives just a rough estimation of execution times, and the results can differ between machines and JVMs.

5. Intrinsic Candidates

It's worth noting that in HotSpot JVM 16, both Arrays.copyOf() and System.arraycopy() are marked as @IntrinsicCandidate. This annotation means that the annotated method can be replaced with faster low-level code by the HotSpot VM.

The JIT compiler can (for some or all architectures) substitute intrinsic methods with machine-dependent, greatly optimized instructions. Since native methods are a black box to the compiler, with significant call overhead, the performance of both methods can be better. Again, such performance gains aren't guaranteed.

6. Conclusion

In this example, we've looked into the performance of System.arraycopy() and Arrays.copyOf(). First, we analyzed the source code of both methods. Second, we set up an example benchmark to measure their average execution times.

As a result, we have confirmed our theory that because Arrays.copyOf() uses System.arraycopy(), the performance of both methods is very similar.

As usual, the examples used in this article are available over on GitHub.