Difference between various Array copy methods

• System.arraycopy() uses JNI (Java Native Interface) to copy an array (or parts of it), so it is blazingly fast, as you can confirm here;
• clone() creates a new array with the same characteristics as the old array, i.e., same size, same type, and same contents. Refer to here for some examples of clone in action;
• manual copying is, well, manual copying. There isn't much to say about this method, except that many people have found it to be the most performant.
• arraynew = arrayold doesn't copy the array; it just points arraynew to the memory address of arrayold or, in other words, you are simply assigning a reference to the old array.

• System.arraycopy() copies data from one existing array into another one and depending on the arguments only copies parts of it.
• clone() allocates a new array that has the same type and size than the original and ensures that it has the same content.
• manual copying usually does pretty much the same thing than System.arraycopy(), but is more code and therefore a bigger source for errors
• arraynew = arrayold only copies the reference to the array to a new variable and doesn't influence the array itself

There is one more useful option:

Arrays.copyOf() can be used to create a copy of another array with a different size. This means that the new array can be bigger or larger than the original array and the content of the common size will be that of the source. There's even a version that makes it possible to create an array of a different type, and a version where you can specify a range of elements to copy (Array.copyOfRange()).

Note that all of those methods make shallow copies. That means that only the references stored in the arrays are copied and the referenced objects are not duplicated.

Arrays.copyOf(..) uses System.arrayCopy(..) method internally.

There are answers but not a complete one.

The options considered are

• Arrays.copyOf()
• System.arraycopy()

Below is the java implementation of Arrays.copyOf()

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

As you can see copyOf uses System.arraycopy internally.

• If you already have an array created use System.arraycopy() to copy
• If you need the result in a new array use Arrays.copyOf() to copy

Note: There is no point in comparing the speed obviously because their functionalities differ.