I was surprised to see in the Java source that System.arraycopy is a native method.
Of course the reason is because it's faster. But what native tricks is the code able to employ that make it faster?
Why not just loop over the original array and copy each pointer to the new array - surely this isn't that slow and cumbersome?
In native code, it can be done with a single memcpy / memmove, as opposed to n distinct copy operations. The difference in performance is substantial.
It can't be written in Java. Native code is able to ignore or elide the difference between arrays of Object and arrays of primitives. Java can't do that, at least not efficiently.
And it can't be written with a single memcpy, because of the semantics required by overlapping arrays.
There are a few reasons:
The JIT is unlikely to generate as efficient low level code as a manually written C code. Using low level C can enable a lot of optimizations that are close to impossible to do for a generic JIT compiler.
See this link for some tricks and speed comparisons of hand written C implementations (memcpy, but the principle is the same): http://www.embedded.com/columns/technicalinsights/19205567?_requestid=457721
The C version is pretty much independant of the type and size of the array members. It is not possible to do the same in java since there is no way to get the array contents as a raw block of memory (eg. pointer).
It is, of course, implementation dependent.
HotSpot will treat it as an "intrinsic" and insert code at the call site. That is machine code, not slow old C code. This also means the problems with the signature of the method largely go away.
A simple copy loop is simple enough that obvious optimisations can be applied to it. For instance loop unrolling. Exactly what happens is again implementation dependent.
My take is that reason that System.arraycopy is native at least partly historical.
In the early days when Java was only interpreted, a native code implementation of arraycopy would have been substantially faster than an equivalent loop written in Java. The arraycopy method would have been essential in making (for example) I/O and graphics performance bearable.
Of course, things have changed. Java is now JIT compiled, and the native code compiler can do all sorts of clever things to make simple loops go fast. So it is not obvious that a native implementation of arraycopy makes a significant difference, "intrinsic" treatment not-withstanding. However, the name, signature and semantics of arraycopy are so entrenched that they are likely to remain unchanged for as long as Java (as we know it) is used.