Array Basics in Java

Suppose a program must process the names of one thousand people. The first idea many learners have is to declare one thousand variables to hold the names and write one thousand print statements to display them. That approach feels reasonable at first, but it becomes unworkable very quickly. An array is the structure designed for exactly this situation.

An array solves the problem by keeping the whole list under a single name. One variable represents the entire collection, and you reach any individual item through its position in that collection. Instead of giving each person their own variable, the collection gets one variable, and each item is found by number.

Two rules shape arrays in Java. First, every item in the array must be of the same type, called the base type. Second, the numbering always begins at zero. Some other programming languages do not impose the same-type rule, so this belongs to the Java setting rather than to arrays in general.

Read the diagram from left to right. The first name is at index 0 and the last name is at index 4. The highest index is always one less than the length, which follows directly from numbering that begins at zero. A learner who reads the first position as index 1 has made the most common indexing error, which is covered later in this article.

Three terms describe any array. The length is the number of items the array contains. The base type is the type shared by the individual items. The index is the position number of one particular item. Keeping these three apart is the key to reading array descriptions correctly.

An array can be understood as a list of variables. An array of ints can be read as a list of variables of type int, and an array of Strings as a list of variables of type String. The source is explicit that an array is not, properly speaking, just a list of integers or strings. It is better thought of as a collection of variables, each of which can hold a value of the array's base type.

Suppose you have an array and want a second array with the same values. Java provides the tool for this. The static method Arrays.copyOf lives in the class Arrays, which is in the package java.util. You call it with two things: the array to copy and the length you want the result to have. It returns a new array of that length, and the new array receives items copied from the original.

The requested length controls how many items can be copied. When the requested length is larger than the original, the extra positions receive default values: zero for numeric arrays, null for object arrays, and so on. When the requested length is smaller than or equal to the original, only as many items are copied as will fit. The length argument alone decides the result's size, so the same method can produce a bigger array, a smaller array, or an exact duplicate.

Arrays.copyOf is a function, so it does not change its input. It hands back a fresh array. To keep the result, assign it to a variable. Writing the call without an assignment computes a copy that is immediately thrown away, so the program has nothing to use afterward.

Resizing is the main reason to use copyOf. Consider a list of players where only the first few positions hold real entries. Passing twice the current length produces a larger array in one line, which doubles the space available. Passing half the length produces a smaller array, which is useful when most of the space would otherwise sit empty. The source describes deleting a player by copying the last filled entry into the removed position and reducing the count. When the count falls below a quarter of the array's capacity, the array can be cut in half with copyOf. Entries beyond the new length are simply dropped, and the entries that survive are kept.

When you want a simple copy with exactly the same size as the original, there is a shorter route. Every array has an instance method named clone() that makes a copy of the array. You call it on the array itself rather than passing the array to a static method.

clone() has no length argument, so it cannot resize. If you need a different size, Arrays.copyOf is the tool. If you need only a same-size copy, clone() expresses that intent more directly.

The copying behavior above was described for arrays of numbers. Arrays of objects behave differently in one important way. The Arrays class contains a copyOf method for each primitive type and one for objects. When an array of objects is copied, only the references to the objects are copied into the new array. The contents of the objects are not copied. This is the usual rule for assignment of references, and the result is called a shallow copy.

When a copied array produces a surprising result, work through the sequence in order. First, identify whether the copy was made with Arrays.copyOf or clone(), and what size you expected. Second, check whether the array holds primitive values or object references. Third, check whether a later line changed the array through the copy or through the original. Each check points to a specific place where the result could diverge.