Mistake #1

Off-by-One: Using <= Instead of <

The single most common array error on the AP CSA exam. An array of length 5 has valid indices 0 through 4. Using <= in the loop condition tries to access index 5, which does not exist.

int[] data = {10, 20, 30, 40, 50};
for (int i = 0; i <= data.length; i++)
{
    System.out.println(data[i]);
}

This throws ArrayIndexOutOfBoundsException on the last iteration when i equals 5.

int[] data = {10, 20, 30, 40, 50};
for (int i = 0; i < data.length; i++)
{
    System.out.println(data[i]);
}

Mistake #2

Confusing .length With .size()

Arrays use .length (no parentheses — it is a field, not a method). ArrayList uses .size() (with parentheses — it is a method call). Mixing them up is a compile-time error.

int[] nums = {1, 2, 3};
System.out.println(nums.size());   // compile error

ArrayList words = new ArrayList();
System.out.println(words.length);  // compile error

int[] nums = {1, 2, 3};
System.out.println(nums.length);   // 3

ArrayList words = new ArrayList();
words.add("hello");
System.out.println(words.size());  // 1

Mistake #3

Using == Instead of .equals() for Strings in Arrays

When you compare String objects in an array, == checks if they are the exact same object in memory. .equals() checks if the characters match. On the exam, they are almost never the same object.

String[] names = {"Ana", "Ben", "Cal"};
String target = new String("Ben");
for (int i = 0; i < names.length; i++)
{
    if (names[i] == target)
    {
        System.out.println("Found at " + i);
    }
}
// Prints nothing — == compares references, not content

String[] names = {"Ana", "Ben", "Cal"};
String target = new String("Ben");
for (int i = 0; i < names.length; i++)
{
    if (names[i].equals(target))
    {
        System.out.println("Found at " + i);
    }
}
// Prints: Found at 1

Mistake #4

Trying to Modify Array Elements With an Enhanced For Loop

The enhanced for loop gives you a copy of each element’s value. Assigning to the loop variable does not change the original array.

int[] scores = {70, 80, 90};
for (int s : scores)
{
    s = s + 10;  // modifies the LOCAL copy only
}
// scores is still {70, 80, 90}

int[] scores = {70, 80, 90};
for (int i = 0; i < scores.length; i++)
{
    scores[i] = scores[i] + 10;
}
// scores is now {80, 90, 100}

Mistake #5

Array Aliasing — Two Variables, One Array

When you assign one array variable to another, both point to the same array in memory. This is aliasing. Changing one changes the other.

int[] original = {1, 2, 3};
int[] copy = original;   // NOT a copy — same array
copy[0] = 99;
System.out.println(original[0]);  // prints 99

int[] original = {1, 2, 3};
int[] copy = new int[original.length];
for (int i = 0; i < original.length; i++)
{
    copy[i] = original[i];
}
copy[0] = 99;
System.out.println(original[0]);  // prints 1

Mistake #6

Forgetting That New Object Arrays Default to null

When you create an array of objects (Strings, custom objects), every slot starts as null — not an empty String, not a default object. Calling a method on null throws NullPointerException.

String[] words = new String[3];
System.out.println(words[0].length());
// NullPointerException — words[0] is null

String[] words = new String[3];
words[0] = "hello";
words[1] = "world";
words[2] = "test";
System.out.println(words[0].length());  // prints 5

Mistake #7

Starting max/min at 0 Instead of the First Element

If you initialize max to 0 and all values in the array are negative, your “maximum” will be 0 — a value that is not even in the array.

int[] vals = {-5, -2, -8, -1};
int max = 0;  // WRONG starting value
for (int i = 0; i < vals.length; i++)
{
    if (vals[i] > max)
    {
        max = vals[i];
    }
}
System.out.println(max);  // prints 0, not -1

int[] vals = {-5, -2, -8, -1};
int max = vals[0];  // start with actual first element
for (int i = 1; i < vals.length; i++)
{
    if (vals[i] > max)
    {
        max = vals[i];
    }
}
System.out.println(max);  // prints -1

Mistake #8

Wrong Index Math in 2D Arrays

In a 2D array, arr.length gives the number of rows. arr[0].length gives the number of columns. Swapping these in a nested loop accesses out-of-bounds indices when the grid is not square.

int[][] grid = new int[3][5];  // 3 rows, 5 columns
for (int r = 0; r < grid[0].length; r++)   // 5 — wrong for rows
{
    for (int c = 0; c < grid.length; c++)  // 3 — wrong for cols
    {
        grid[r][c] = r + c;
        // crashes when r=3 (only 0,1,2 are valid rows)
    }
}

int[][] grid = new int[3][5];  // 3 rows, 5 columns
for (int r = 0; r < grid.length; r++)       // 3 rows
{
    for (int c = 0; c < grid[0].length; c++) // 5 columns
    {
        grid[r][c] = r + c;
    }
}