What is System.arraycopy and what do its five parameters mean?
answer
- src, srcPos, dest, destPos, length
- copies a range, not the whole array
- src and dest may be the same array
- native method — the JDK's copy primitive
- NPE / IndexOOB / ArrayStoreException
basics
~10 sSystem.arraycopy copies a range of elements from one array to another. You pass the source array, where to start reading, the destination array, where to start writing, and how many elements to copy.
solid answer
~40 sSystem.arraycopy(src, srcPos, dest, destPos, length) is a native method that copies length elements from src starting at index srcPos into dest starting at index destPos. The source and destination can be the same array (it handles overlap correctly). It is the fundamental low-level copy primitive in the JDK: ArrayList, StringBuilder, Arrays.copyOf, and many collections call it under the hood. Because it is implemented in native/intrinsic code, the JIT can turn it into a fast block memory move rather than an element-by-element loop. It throws NullPointerException if either array is null, ArrayStoreException on incompatible element types, and IndexOutOfBoundsException if any index or the length is out of range.
go deeper
Can state the parameter order and explain it copies a range of elements into an existing destination array.
Knows the exceptions it throws, that source and destination may be the same array, and that it is void (writes in place).
Explains that it is the JDK's underlying copy primitive used by ArrayList/StringBuilder/Arrays, and the difference between primitive (checked-first) and reference (per-element checked) copies.
Discusses it as a JIT intrinsic, when partial copies can occur on ArrayStoreException, and API design tradeoffs of an Object-typed native primitive vs a typed wrapper.
## What an array is An **array** in Java is a fixed-size, contiguous block of memory holding elements of one type, accessed by integer **index** (position) starting at 0. Arrays cannot grow; to "resize" you allocate a new array and copy the old elements over. That copying is exactly what `System.arraycopy` exists to make fast. ## The method `System` is a built-in JDK class of utility methods. `arraycopy` is a **native** method on it — meaning its body is written in the JVM's own code (C/C++/intrinsic), not in Java. Its full signature is: ``` public static native void arraycopy( Object src, int srcPos, Object dest, int destPos, int length) ``` The five parameters, in order: - **`src`** — the array to copy *from* (the source). - **`srcPos`** — the index in `src` where reading begins. - **`dest`** — the array to copy *into* (the destination). It can be the **same** array as `src`. - **`destPos`** — the index in `dest` where writing begins. - **`length`** — how many elements to copy. So it copies `src[srcPos .. srcPos+length-1]` into `dest[destPos .. destPos+length-1]`. ## A concrete example Given `src = [10, 20, 30, 40, 50]` and a `dest` of size 5 all zeros, calling `System.arraycopy(src, 1, dest, 0, 3)` reads elements at source indices 1,2,3 (`20,30,40`) and writes them to destination indices 0,1,2, giving `dest = [20, 30, 40, 0, 0]`. ## Errors it can throw - **`NullPointerException`** — if `src` or `dest` is `null`. - **`IndexOutOfBoundsException`** (specifically `ArrayIndexOutOfBoundsException`) — if any of `srcPos`, `destPos`, or `length` is negative, or if `srcPos+length` exceeds `src.length`, or `destPos+length` exceeds `dest.length`. - **`ArrayStoreException`** — if an element in the source range cannot be stored into the destination because of incompatible types (e.g. copying an `Object[]` that contains a `String` into an `Integer[]`). Importantly, the bounds and type checks happen **before** any copying for primitive arrays, so a failed call doesn't leave the destination half-copied in those cases; for reference arrays where element types are checked per-element, a partial copy can occur before an `ArrayStoreException`. ## Why it matters It is the lowest-level copy primitive in the JDK. `ArrayList.add` (when growing), `StringBuilder.append`, `Arrays.copyOf`, `Arrays.copyOfRange`, and `Collections` all delegate to it. Knowing its parameter order and that source/dest may be the same array is everyday Java fluency.
- Does System.arraycopy create the destination array for you?No. It writes into an array you have already allocated; if dest is null you get a NullPointerException, and if dest is too small you get an IndexOutOfBoundsException. Use Arrays.copyOf when you want a freshly-sized array created for you.
- What happens if length is 0?Nothing is copied and no exception is thrown (as long as the arrays are non-null and the positions are valid for a zero-length range). It is a legal no-op.
saying these in an interview costs you the question
- Thinking it returns a new array — it returns void and writes into an existing dest
- Forgetting the parameter order (mixing up srcPos and destPos)
- Believing it allocates the destination — you must allocate dest yourself
- Assuming it copies the entire source array regardless of length