An array is the simplest data structure Java has and the one closest to the machine: a fixed-length block of elements of one type, indexed from zero, laid out contiguously. Every other collection is built on it. This lesson covers how arrays are declared, created and indexed, what an array is at run time, and the errors that come from forgetting any of that.

Declaring and creating

int[] counts;                     // declares a variable of type "array of int"; holds null
counts = new int[10];             // creates an array of 10 ints, all 0
int[] primes = {2, 3, 5, 7};      // array initialiser — length 4, only in a declaration
int[] more = new int[] {11, 13};  // the same, usable anywhere (arguments, reassignment)
String[] names = new String[3];   // three nulls
double[] empty = new double[0];   // a legal, empty array

Two things to notice. First, the type is int[] — "array of int" — and the variable is a reference; counts is null until an array is assigned. Second, the length is fixed at creation: new int[10] is ten slots forever. To "grow" an array you create a bigger one and copy (that is exactly what ArrayList does internally).

int counts[] (C style) is also accepted by the compiler and rejected by every style guide. Put the brackets on the type.

Default values

new T[n] fills every slot with the default for T: 0 for numeric types, '\u0000' for char, false for boolean, null for any reference type. This is guaranteed — unlike C, an array is never uninitialised memory. The null defaults in a String[] are the source of many early NullPointerExceptions: names[0].length() before any assignment.

Indexing and length

int[] a = {10, 20, 30};
a[0]          // 10 — the first element
a[2]          // 30 — the last: index length - 1
a.length      // 3 — a final FIELD, no parentheses (String.length() is a method)
a[3]          // ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
a[-1]         // ArrayIndexOutOfBoundsException: Index -1 out of bounds for length 3
a[1] = 25;    // assignment
a[1] += 5;    // compound assignment works on elements

Indices run from 0 to length - 1. Every access is bounds-checked at run time; an out-of-range index throws immediately, with a message naming the index and the length. This costs a comparison per access (the JIT eliminates most of them in loops) and buys the memory safety C lacks.

The canonical loop is for (int i = 0; i < a.length; i++), and when the index is not needed, for (int v : a).

Arrays are objects

Every array is an object on the heap, even int[]:

• It has a length and a runtime type (int[].class, String[].class).
• Array variables hold references; int[] b = a; makes b and a the same array (next lessons).
• a == b compares references, not contents; a.equals(b) is the same as == (arrays do not override it). Use Arrays.equals.
• a.toString() gives [I@1b6d3586 (type code and hash), not the contents. Use Arrays.toString.
• An array's superclass is Object; it implements Cloneable and Serializable; a.clone() makes a shallow copy.
• Object[] o = new String[3]; compiles — arrays are covariant — and o[0] = 1; then throws ArrayStoreException at run time. Generics were designed the opposite way to avoid exactly this.

Arrays of primitives versus arrays of objects

int[] holds the numbers themselves, contiguously: 1000 ints are 4000 bytes plus a header. Integer[] holds 1000 references to Integer objects scattered on the heap. For numeric work, primitive arrays are several times faster and smaller — the reason they exist alongside List<Integer>.

Multidimensional preview

int[][] grid = new int[3][4]; — an array of 3 arrays of 4 ints. The next lesson covers these.

Common errors

Arrays and main

String[] args in main is an ordinary array: args.length is the number of command-line arguments and args[0] the first. It is never null — with no arguments it is an empty array.

When to use an array

• Fixed size known up front; numeric or character data; performance matters; multi-dimensional grids.
• Otherwise, ArrayList (Module 14) — it grows, has add/remove/contains, and its toString is readable. The switch costs little; arrays remain the right tool for algorithms and hot loops.

Interview angle

• "Are arrays objects in Java?" Yes — heap-allocated, with a length field and a runtime type; variables hold references.
• "Can you change an array's size?" No; create a new one and copy (Arrays.copyOf).
• "a.length vs s.length() vs list.size()?" Field, method, method — a classic trick question.
• "What is stored in new String[5]?" Five nulls.

Key takeaways

• T[] a = new T[n] — fixed length, zero-based, every slot defaulted (0/false/null).
• a.length is a field; valid indices are 0 … length - 1; every access is bounds-checked.
• Arrays are objects: variables are references, == is identity, toString is unreadable — use the Arrays class.
• Primitive arrays are contiguous values; object arrays are references.