Copying Arrays Element by Element

Assignment is one of the first things you learn in programming, and it usually feels simple. When an integer is assigned to a second variable, the second variable receives its own independent value. Changing one later never touches the other. Many learners carry this picture straight over to arrays, and that is where surprises begin.

The belief goes something like this: assigning one array variable to another gives you a duplicate array, so each variable now owns a separate collection of elements. This belief feels reasonable, and it is the single most common source of confusion when array code produces a value nobody expected. The belief is wrong for arrays. This article shows exactly what happens instead, so that you can look at an assignment line, know what it did, and predict the consequences for every later read and write.

Think of two sticky notes that both point at the same filing cabinet. Writing on the cabinet through either note changes what anyone sees inside it, and nothing about the cabinet is duplicated when you add a second note. The variable names in an array assignment behave like those sticky notes. They are labels attached to one shared object.

The diagram below shows the structure that an assignment creates. There are two variable names and one array object. The count of array objects is the important number. It stays at one, because the assignment never built a second one. Any read or write through either name reaches the same set of elements.

Once you hold this picture, the behavior of the assignment follows directly rather than feeling like an exception. The question to ask about any array variable is not what elements it owns, but which array object it currently names.

The assignment statement has a precise effect that is easy to state. It takes the reference value stored in the right-hand variable and stores that same reference value in the left-hand variable. The left-hand variable becomes a second name for the array the right-hand variable already named. No element is moved, no element is duplicated, and no new array is allocated by that line.

The before and after views show a single array. The write changed one element of that array, and both names see it, because both names lead to the same object. The diagram has no second array to update.

Tracing means following each statement in order and recording what every variable names after that statement runs. The sequence diagram below does this for a short program. Each arrow is one statement that touches the array or a variable.

A variable that holds a reference can also hold null, which means it refers to no array at all. The same reference-copying rule applies here. If the right-hand variable is null, the left-hand variable also becomes null after the assignment. The two variables still agree about what they refer to, which is nothing.

Because assignment does not duplicate elements, an independent copy requires explicitly creating a new array and copying the values. A common approach is to create a new empty array and copy each value across with a loop. After the loop, the two names refer to two different array objects that happen to hold the same values at that moment.