Introduction to ArrayList Traversals

In the previous chapter, we learned how to create an ArrayList and use its basic methods like add and remove. But what if you want to look at every single item in your list to find the total, check for a specific value, or delete items that meet a certain condition? This process of "visiting" every element is called traversal.

Traversing an ArrayList is similar to traversing a standard array, but since ArrayLists are objects, we use methods instead of square brackets. Don't worry if this seems a bit different at first—once you master the two main types of loops, you'll be able to handle any data set with ease!

Method 1: The Standard for Loop

The standard for loop is the most flexible way to traverse an ArrayList. It uses an index variable (usually \(i\)) to keep track of where you are in the list.

The Syntax:
for (int i = 0; i < listName.size(); i++) {
    Type element = listName.get(i);
    // Do something with the element
}

Key Rules for the Standard for Loop:
  • Start at 0: Just like arrays, ArrayList indices begin at \(0\).
  • Use .size(): Unlike arrays (which use .length), you must use the size() method to find the number of elements.
  • Use .get(i): You cannot use [i]. You must call the get(index) method to retrieve an item.
  • Stop at size() - 1: The loop condition should be \(i < list.size()\).

Quick Review: If an ArrayList has \(5\) elements, size() returns \(5\), and the valid indices are \(0, 1, 2, 3,\) and \(4\).

Method 2: The Enhanced for Loop (For-Each)

The enhanced for loop is a "shortcut" when you want to look at every item from start to finish without worrying about indices.

The Syntax:
for (Type name : listName) {
    // Use 'name' to represent the current item
}

When to use the Enhanced for Loop:
  • When you only need to read the data.
  • When you don't care about the index (position) of the items.
  • When you are not adding or removing items during the loop.

Common Mistake: You cannot use an enhanced for loop if you need to know the index of an element or if you want to modify the structure of the list (like deleting items).

The "Removal Trap": Modifying During Traversal

This is one of the most common topics on the AP Exam! If you try to remove an item while moving forward through an ArrayList, you will likely run into a logic error.

Why does it fail?

When you call remove(i), every element to the right of \(i\) shifts one position to the left to fill the gap. If your loop then does \(i++\), you will skip the element that just shifted into position \(i\)!

The Solution: Loop Backwards!

To safely remove items during a traversal, start at the last index and move toward \(0\). This way, when elements shift, they shift into positions you have already checked.

The "Safe" Removal Pattern:
for (int i = list.size() - 1; i >= 0; i--) {
    if (/* some condition */) {
        list.remove(i);
    }
}

Memory Trick: "To get it right, start from the right!"

Traversing with Wrapper Classes

Remember that ArrayLists can only store Objects, not primitives like int or double. Java uses Wrapper Classes (Integer and Double) to handle this.

  • Autoboxing: Java automatically converts an int to an Integer object when you add it to the list.
  • Unboxing: Java automatically converts an Integer object back to an int when you get it from the list.

Because of this, you can usually write your loops using int or double and Java will handle the conversion for you behind the scenes.

Summary and Key Takeaways

Standard for loop: Use when you need the index or need to modify the list. Remember to use .size() and .get(i).

Enhanced for loop: Use for simple "read-only" tasks where the index doesn't matter. It's cleaner and prevents "off-by-one" errors.

Safe Removal: Always traverse backwards (from \(size() - 1\) down to \(0\)) if you plan on removing elements during the loop to avoid skipping items.

Note: For more complex operations using these traversals, see the next chapter: "Implementing ArrayList Algorithms."