Array Traversals

Lesson ~10 min read 8 MCQs

In simple terms: In simple terms, array traversal is about visiting each item in an array, one by one, to read, count, or check its value, much like checking off items on a list.

Why this matters

Imagine you’re building a feature for a shopping app. A user, let's call her Maya, has added five items to her cart. To show her the total price, your program needs to look at the price of the first item, add it to a running total, then look at the second item's price, add it, and so on, until it has "visited" every single item in her cart. You can't miss any, and you shouldn't count any twice.

Maya's shopping cart items, ready for traversal to calculate the total.

This process of systematically visiting each element in a collection is called traversal. It’s one of the most fundamental and common tasks in programming. Today, we'll master the two main ways to traverse arrays in Java: the classic indexed for loop and the convenient enhanced for loop.

Concept overview

flowchart TD
    A[Start: I need to traverse an array] --> B{Do I need the element's index?};
    B -- Yes --> C[Use an indexed for loop<br>for (int i=0; i < arr.length; i++)];
    B -- No --> D{Do I need to change the values<br>in a primitive array?};
    D -- Yes --> C;
    D -- No --> E[Use an enhanced for loop<br>for (Type var : arr)];
    C --> F[You can access arr[i] and i];
    E --> G[You can access each element directly];
    G --> H{Can I modify objects this way?};
    H -- Yes --> I[s.setGPA() works!];
    H -- No --> J[This is a common misconception];
    F --> K[End];
    I --> K;

Core explanation

Once you have data stored in an array, the next logical step is to do something with that data. You might want to find the highest score, calculate the average, or search for a specific name. All these tasks require you to look through the array's elements one by one. This is traversal.

Think of an array as a row of numbered lockers in a school hallway. Traversing that array is like walking down the hall and opening each locker in order to inspect its contents.

The Classic Tool: The Indexed `for` Loop

The most common and flexible way to traverse an array is with a standard for loop that uses an index variable. This is like having a list of locker numbers (0, 1, 2, 3...) and visiting each one explicitly.

Let's say we have an array of test scores:

int[] scores = {88, 95, 72, 100, 91};

To print each score, we can use an indexed for loop:

Tracing an indexed `for` loop through the `scores` array.

// Standard indexed for loop
for (int i = 0; i < scores.length; i++) {
  System.out.println("Score at index " + i + ": " + scores[i]);
}

Output:

Score at index 0: 88
Score at index 1: 95
Score at index 2: 72
Score at index 3: 100
Score at index 4: 91

Let's break that down:

int i = 0;: We declare an index variable, i, and start it at 0. This is crucial because array indices always start at 0.
i < scores.length;: The loop continues as long as i is less than the length of the array. For our 5-element array, scores.length is 5. The loop will run for i values 0, 1, 2, 3, and 4. When i becomes 5, the condition 5 < 5 is false, and the loop stops. This prevents the infamous ArrayIndexOutOfBoundsException.
i++: After each iteration, we increment our index to move to the next element.
scores[i]: Inside the loop, we use the index i to access the element at that specific position.

You can also use a while loop to do the same thing, but you have to manage the index variable yourself. Indexed for loops are generally preferred because they package the initialization, condition, and increment all in one line.

The Convenient Shortcut: The Enhanced `for` Loop

Sometimes, you don't care about the index. You just want to get each element, one after another. For these situations, Java gives us the enhanced for loop (also called a "for-each" loop).

It's like telling a friend, "For each locker in this hallway, just tell me what's inside." You don't care if it's locker #0 or locker #27; you just want the contents.

Here's the same task using an enhanced for loop:

// Enhanced for loop
for (int score : scores) {
  System.out.println("A score is: " + score);
}

Output:

A score is: 88
A score is: 95
A score is: 72
A score is: 100
A score is: 91

The syntax for (int score : scores) reads as "for each int score in the scores array...".

On the first pass, the variable score is automatically assigned a copy of scores[0] (which is 88).
On the second pass, score is assigned a copy of scores[1] (which is 95).
...and so on, until every element has been visited.

A Critical Distinction: Modifying Elements

This is where many students get stuck. The behavior of assignment within a loop depends on whether you're using an indexed loop or an enhanced loop, and whether your array holds primitives (int, double) or objects (String, or custom objects like Student).

1. Primitives and the Enhanced for Loop

When you use an enhanced for loop with primitives, the loop variable gets a copy of the value. Changing that copy does not change the original array.

Imagine you have a photocopy of a page from a book. If you write on the photocopy, does the original book change? No.

int[] numbers = {10, 20, 30};

// Let's try to double every number
for (int num : numbers) {
  num = num * 2; // This only changes the copy, 'num'
}

// Now let's print the array to see what happened
// The original array is UNCHANGED.
System.out.println(numbers[0]); // Prints 10, not 20

Assigning a new value to num has no effect on the numbers array itself. If you need to modify the elements of a primitive array, you must use an indexed for loop.

// The correct way to modify the array
for (int i = 0; i < numbers.length; i++) {
  numbers[i] = numbers[i] * 2; // This directly accesses and changes the array
}
System.out.println(numbers[0]); // Prints 20

2. Objects and the Enhanced for Loop

This gets a little more nuanced. When an array stores objects, the array actually holds references—think of them as addresses pointing to where the objects live in memory.

When you use an enhanced for loop with an array of objects, the loop variable gets a copy of the reference.

Here's the analogy: Instead of a photocopy of a page, you get a photocopy of a key to a house. You can't use your copy of the key to change which house it opens (you can't change the reference), but you can use it to unlock the door and go inside to redecorate (you can change the object's state).

Let's say we have a simple Student class:

class Student {
  private String name;
  private double gpa;
  // constructor, getters, setters...
  public void setGpa(double newGpa) {
    this.gpa = newGpa;
  }
}

Student[] myStudents = { new Student("Priya", 3.8), new Student("Carlos", 3.5) };

// Let's give everyone a GPA boost
for (Student s : myStudents) {
  s.setGpa(s.getGpa() + 0.1); // This WORKS!
}

In this case, s is a copy of the reference to a Student object. The line s.setGpa(...) uses that reference to find the original Student object in memory and call a method on it. The object itself is modified. The array still holds the same references to the same objects, but the objects themselves have changed.

Any traversal written with an enhanced for loop can be rewritten with an indexed for loop. The reverse is not always true, especially if you need the index for your logic.

Comparing `for` loop conditions: avoiding `ArrayIndexOutOfBoundsException`.

See it in action

Code

Memory

Variables

Step 0 / 0

Worked examples

Let's walk through a few common scenarios to make this concrete.

Example 1

Calculating the Total Cost

Problem: You have an array of doubles representing the prices of items in a shopping cart. Calculate the total cost, then add a 6% sales tax (like in Dallas, TX).

double[] prices = {19.99, 45.50, 5.25, 89.99};

Solution Walkthrough:

1
Goal
We need to sum up all the values in the prices array. This is a classic traversal task.
2
Loop Choice
We just need to read each value. We don't need the index. An enhanced for loop is a perfect, clean choice.
3
Initialize a Total
Before the loop starts, we need a variable to keep track of our running total. Let's call it subtotal and initialize it to 0.0.
4
Write the Loop
We'll loop through each price in the prices array and add it to our subtotal.
5
Calculate Final Price
After the loop finishes, subtotal will hold the sum of all prices. We then calculate the tax and add it to get the final total.

Code:

double[] prices = {19.99, 45.50, 5.25, 89.99};
double subtotal = 0.0;

// Use an enhanced for loop to sum the prices



<figure class="lesson-figure"><div class="shr-widget" data-shr-widget="{&quot;code&quot;:[&quot;double[] prices = {19.99, 45.50, 5.25, 89.99};&quot;,&quot;double subtotal = 0.0;&quot;,&quot;for (double price : prices) {&quot;,&quot;    subtotal += price;&quot;,&quot;}&quot;],&quot;type&quot;:&quot;for_loop_trace&quot;,&quot;array&quot;:[19.99,45.5,5.25,89.99],&quot;trace_steps&quot;:[{&quot;line&quot;:2,&quot;vars&quot;:{&quot;subtotal&quot;:0}},{&quot;line&quot;:3,&quot;vars&quot;:{&quot;price&quot;:19.99,&quot;subtotal&quot;:0},&quot;highlight_cell&quot;:0},{&quot;line&quot;:4,&quot;vars&quot;:{&quot;price&quot;:19.99,&quot;subtotal&quot;:19.99},&quot;highlight_cell&quot;:0},{&quot;line&quot;:3,&quot;vars&quot;:{&quot;price&quot;:45.5,&quot;subtotal&quot;:19.99},&quot;highlight_cell&quot;:1},{&quot;line&quot;:4,&quot;vars&quot;:{&quot;price&quot;:45.5,&quot;subtotal&quot;:65.49},&quot;highlight_cell&quot;:1},{&quot;line&quot;:3,&quot;vars&quot;:{&quot;price&quot;:5.25,&quot;subtotal&quot;:65.49},&quot;highlight_cell&quot;:2},{&quot;line&quot;:4,&quot;vars&quot;:{&quot;price&quot;:5.25,&quot;subtotal&quot;:70.74},&quot;highlight_cell&quot;:2},{&quot;line&quot;:3,&quot;vars&quot;:{&quot;price&quot;:89.99,&quot;subtotal&quot;:70.74},&quot;highlight_cell&quot;:3},{&quot;line&quot;:4,&quot;vars&quot;:{&quot;price&quot;:89.99,&quot;subtotal&quot;:160.73},&quot;highlight_cell&quot;:3}]}" aria-label="An animation showing an enhanced for loop. The &#039;price&#039; variable takes on each value from the &#039;prices&#039; array sequentially, and &#039;subtotal&#039; accumulates the sum."></div><figcaption class="lesson-figure-caption">Tracing an enhanced `for` loop to calculate the subtotal of prices.</figcaption></figure>



for (double price : prices) {
  subtotal += price; // same as subtotal = subtotal + price;
}

// Now calculate the final total with a 6% tax
double taxRate = 0.06;
double taxAmount = subtotal * taxRate;
double finalTotal = subtotal + taxAmount;

// Let's print it out, formatted nicely
System.out.printf("Subtotal: $%.2f\n", subtotal);
System.out.printf("Total with tax: $%.2f\n", finalTotal);

Example 2

Finding the First Negative Temperature

Problem: You have an array of daily high temperatures for a week in Boston in January. Find the index of the first day the temperature dropped below freezing (0°F). If all temperatures are at or above freezing, return -1.

int[] temps = {12, 8, 2, -5, 3, -1, 6};

Solution Walkthrough:

1
Goal
We need to find the index of a specific value.
2
Loop Choice
Because the problem explicitly asks for the index, we must use an indexed for loop. An enhanced for loop won't work here because it doesn't give us the index.
3
Write the Loop
We'll iterate from i = 0 up to the end of the array.
4
Check the Condition
Inside the loop, we'll check if temps[i] < 0.
5
Exit Early
As soon as we find the first negative temperature, we've accomplished our goal. We can print the index and stop searching. A return statement or a break is perfect for this. If we finish the entire loop without finding a negative number, we know none exist.

Code:

int[] temps = {12, 8, 2, -5, 3, -1, 6};
int firstFreezingIndex = -1; // Default value if none are found

for (int i = 0; i < temps.length; i++) {
  if (temps[i] < 0) {
    firstFreezingIndex = i;
    break; // We found it! Exit the loop immediately.
  }
}

System.out.println("The first day below freezing was at index: " + firstFreezingIndex);
// Output: The first day below freezing was at index: 3

Avoiding common mistakes when initializing accumulator variables.

Try it yourself

Time to put your knowledge into practice. Don't just read—code!

Problem 1: Find the Max

Write a method findMax that takes an array of integers and returns the largest value in the array. For example, if the input is {1, 9, 2, 8, 5}, your method should return 9.

Hint
You'll need a variable to keep track of the "biggest value seen so far." Initialize it to the first element of the array before the loop starts. Then, loop through the rest of the elements, updating your variable whenever you find a bigger one.
Hint
Can you use an enhanced for loop for this? Yes, because you don't need the index.

Problem 2: Count Occurrences

Write a method countLetterA that takes an array of Strings and returns how many of the strings start with the letter "A" (case-insensitive). For example, if the input is {"Apple", "Banana", "apricot", "Cherry"}, your method should return 2.

Hint
You'll need a counter variable, initialized to 0 before the loop.
Hint
The String class has helpful methods like startsWith() and toUpperCase() or toLowerCase() to handle the case-insensitivity.

Flowchart for finding the maximum value in an array.

TL;DR

In simple terms, array traversal is about visiting each item in an array, one by one, to read, count, or check its value, much like checking off items on a list.

Syntax pattern

int[] scores = {88, 95, 72, 100, 91};

Key terms

AP Computer Science A Array traversal For loop Enhanced for loop For-each loop Indexed loop Java array Common programming mistakes AP CSA Unit 4 ===END===

You can now…

4.4.A: Develop code used to traverse the elements in a 1D array and determine the result of these traversals.

Essential knowledge (exam-tested)

4.4.A.1: Traversing an array is when repetition statements are used to access all or an ordered sequence of elements in an array.
4.4.A.2: Traversing an array with an indexed for loop or while loop requires elements to be accessed using their indices.
4.4.A.3: An enhanced for loop header includes a variable, referred to as the enhanced for loop variable. For each iteration of the enhanced for loop, the enhanced for loop variable is assigned a copy of an element without using its index.
4.4.A.4: Assigning a new value to the enhanced for loop variable does not change the value stored in the array.
4.4.A.5: When an array stores object references, the attributes can be modified by calling methods on the enhanced for loop variable. This does not change the object references stored in the array.
4.4.A.6: Code written using an enhanced for loop to traverse elements in an array can be rewritten using an indexed for loop or a while loop.

Concept map

flowchart TD
    A[Start: I need to traverse an array] --> B{Do I need the element's index?};
    B -- Yes --> C[Use an indexed for loop<br>for (int i=0; i < arr.length; i++)];
    B -- No --> D{Do I need to change the values<br>in a primitive array?};
    D -- Yes --> C;
    D -- No --> E[Use an enhanced for loop<br>for (Type var : arr)];
    C --> F[You can access arr[i] and i];
    E --> G[You can access each element directly];
    G --> H{Can I modify objects this way?};
    H -- Yes --> I[s.setGPA() works!];
    H -- No --> J[This is a common misconception];
    F --> K[End];
    I --> K;

Read what Saavi narrates

Hi everyone, it's Saavi from Shrutam. Let's talk about one of the most common things you'll ever do in programming.

Imagine you're building a shopping app. A user, Maya, adds five items to her cart. To show her the total price, your code has to look at the first item's price, add it up, then the second, then the third, and so on, until it's visited every single item. This process of systematically visiting each element is called traversal. It's like walking down a list and checking off every item.

In Java, we have two main ways to do this with arrays. The first is the classic indexed for loop, where you use a counter to visit by position: index 0, index 1, index 2... The second is the enhanced for loop, which is simpler. It just says, "give me each item, one by one."

Let's look at a quick example. Say we have an array of prices for items in a cart. We want to find the total.

First, we'd create a variable for the subtotal, and set it to zero. Then, we can use an enhanced for loop. For each price in our prices array, we just add that price to our subtotal. The loop handles grabbing each value for us automatically. After the loop is done, we have our sum. Simple as that.

Now, here's a really common mistake students make. Let's say you have an array of numbers, and you want to double every number in it. You might try an enhanced for loop, like this: for each number in the array, set the number equal to itself times two.

But... it won't work. When you use an enhanced for loop on simple types like numbers, the loop variable is just a *copy*. It's like writing on a photocopy... the original document doesn't change. To actually modify the array, you *must* use the classic indexed for loop, which lets you directly access and change the value at each position.

It's a small detail, but it's critical for the AP exam.

So, remember: traversal is just visiting every element. Use an enhanced for loop when you just need to read values. Use an indexed for loop when you need the element's position or when you need to change the values in the array.

You've got this. Keep practicing, and I'll see you in the next lesson.

Code

Memory

Variables

Step 0 / 0

Back to AP Computer Science A Take a mock exam

Settings & Accessibility

Array Traversals

Why this matters

Concept overview

Core explanation

The Classic Tool: The Indexed `for` Loop

The Convenient Shortcut: The Enhanced `for` Loop

A Critical Distinction: Modifying Elements

See it in action

Worked examples

Calculating the Total Cost

Finding the First Negative Temperature

Try it yourself

Practice — 8 questions

Array Traversals

Why this matters

Concept overview

Core explanation

The Classic Tool: The Indexed for Loop

The Convenient Shortcut: The Enhanced for Loop

A Critical Distinction: Modifying Elements

See it in action

Worked examples

Try it yourself

Practice — 8 questions

The Classic Tool: The Indexed `for` Loop

The Convenient Shortcut: The Enhanced `for` Loop