4.3 Array Creation and Access

A 1D array in Java holds multiple values of the same type under one variable name, and its length is fixed when you create it. You access and change elements with square brackets and an index, where valid indices run from 0 to length - 1. For AP Computer Science A, watch array bounds closely because one off-by-one error can throw an ArrayIndexOutOfBoundsException.

Arrays are the foundation for everything else in Unit 4, which carries the largest weight on the AP Computer Science A exam. Getting array creation and indexing right sets you up for traversals, array algorithms, 2D arrays, searching, and sorting.

On the multiple-choice section, you will trace array code to predict output or spot which line throws an exception. On free-response code writing, you will create arrays, fill them, and access elements correctly, so off-by-one mistakes can cost easy points. The two skills emphasized here are writing code that uses arrays and determining the result of code that uses arrays.

What to Know About Array Creation and Access

• An array stores multiple values of the same type, either primitive values or object references.
• The length is set when the array is created and cannot change; read it with the length attribute (no parentheses).
• Using new initializes every element to a default: 0 for int, 0.0 for double, false for boolean, and null for reference types.
• Initializer lists like {1, 2, 3} create and fill an array in one step.
• Valid indices are 0 through length - 1; anything outside that range throws an ArrayIndexOutOfBoundsException.
• Use square brackets to both read (arr[i]) and modify (arr[i] = value) an element.

Core Concepts

Declaring and Creating Arrays

Declaring an array tells Java the element type and that the variable is an array, marked by square brackets. Creating the array with new reserves space for a fixed number of elements.

</>Java
// Declaration: the brackets can follow the type or the name
int[] scores;        // preferred style
int scores[];        // also valid

// Creation: new reserves space for 7 ints, all set to 0
scores = new int[7];

The length you pass to new is locked in. You cannot grow or shrink an array later; you would have to create a new one.

Default Values

When you create an array with new but do not assign values, every element starts at the default for its type.

</>Java
int[] counts = new int[3];      // {0, 0, 0}
double[] totals = new double[2]; // {0.0, 0.0}
boolean[] flags = new boolean[2];// {false, false}
String[] names = new String[2];  // {null, null}

Initializer Lists

When you already know the values, an initializer list creates and fills the array at the same time. The length is set by how many values you list.

</>Java
int[] primes = {2, 3, 5, 7, 11};   // length 5
String[] days = {"Mon", "Tue", "Wed"}; // length 3

Indexing and Access

Indexing starts at 0, so the first element is at index 0 and the last is at index length - 1. The same square bracket notation reads a value and writes a value.

</>Java
int[] nums = {10, 20, 30, 40};
int first = nums[0];        // reads 10
nums[2] = 99;               // writes 99, array is now {10, 20, 99, 40}
int last = nums[nums.length - 1]; // reads 40

The length Attribute

Every array has a length attribute that gives the number of elements. It is a field, not a method, so there are no parentheses.

</>Java
int[] data = new int[5];
System.out.println(data.length);     // 5
System.out.println(data.length - 1); // 4, the highest valid index

length always equals the number of elements the array was created with, even if some elements still hold their default values.

Worked Examples

Example: Create, fill, and read

</>Java
int[] temps = new int[7];   // 7 zeros
temps[0] = 72;
temps[1] = 75;
// indices 2 through 6 are still 0

System.out.println(temps[0]);                 // 72
System.out.println(temps[temps.length - 1]);  // 0 (last element default)

Example: Initializer list with object references

</>Java
String[] subjects = {"Math", "Science", "English"};
System.out.println(subjects[1]);  // Science
subjects[1] = "Biology";          // modifies index 1
System.out.println(subjects[1]);  // Biology
System.out.println(subjects.length); // 3

Example: Spotting a bounds error

</>Java
int[] arr = {4, 8, 15, 16};   // valid indices 0..3
System.out.println(arr[4]);   // ArrayIndexOutOfBoundsException

Index 4 does not exist because the highest valid index is length - 1, which is 3.

Array Creation and Access on the AP Computer Science A Exam

Code Tracing: When you see array code, write the array out with its indices labeled 0, 1, 2, and so on. Track each assignment as it happens. If a line uses an index, check whether it falls in the range 0 to length - 1 before assuming the code runs.

Code Writing: When you create an array with new, remember the elements start at default values, so you may need a loop to fill them. When you need the last element, use arr[arr.length - 1], not arr[arr.length].

Common Trap: The most frequent slip is a loop condition that uses <= with length, which tries to read arr[arr.length] and throws an exception. Use i < arr.length to stop exactly at the last valid index.

</>Java
// Correct loop bound
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

Common Misconceptions

• Misconception: length is a method.
  Actually: length is not a method. Write arr.length, not arr.length(). It also is not the last index; the last index is length - 1.
• Misconception: An array's size can be changed after creation.
  Actually: An array's size is fixed at creation. You cannot add or remove slots later; you would create a new array.
• Misconception: A declared array is the same as a created one.
  Actually: A declared array is not the same as a created one. int[] nums; only declares the variable. Until you assign it (for example with new), you cannot use it as an array: a local variable gives a compile error, and a field defaults to null, which causes a NullPointerException when used.
• Misconception: An array made with new holds nothing.
  Actually: An array made with new is not empty in the sense of holding nothing. Each slot holds a default value like 0 or null, which is different from an unassigned array variable.
• Misconception: Indices start at 1, not 0.
  Actually: Indices start at 0, not 1. The first element is arr[0], and counting from 1 is a common cause of off-by-one errors.
• Misconception: An ArrayIndexOutOfBoundsException happens when the code compiles.
  Actually: An ArrayIndexOutOfBoundsException happens at run time, not when the code compiles. The compiler will not catch an out-of-range index for you.

Related AP Computer Science A Guides

• 4.4 Traversing Arrays
• 4.5 Developing Algorithms Using Arrays
• 4.14 Searching
• 4.11 2D Arrays
• 4.13 Implementing 2D Array Algorithms
• 4.1 Ethical and Social Implications