4.8 ArrayList Methods

What ArrayList methods are on the AP CSA exam?

ArrayList methods let you build and change a list whose size can grow or shrink while your program runs. For AP Computer Science A you mainly need the methods on the Java Quick Reference: size, both versions of add, get, set, and remove. Knowing exactly what each one returns and how it shifts other elements is the key to tracing and writing correct code.

Why This Matters for the AP Computer Science A Exam

ArrayList shows up on both the multiple-choice and free-response sections. You will trace short code segments to predict output, explain why a segment will not compile or work as intended, and write code that stores and manipulates collections of objects. One of the free-response questions centers on analyzing an ArrayList of objects from a given class, where you often insert or remove elements and adjust your loop to handle shifting indices. Getting comfortable with the exact behavior of each ArrayList method now pays off across the whole exam.

Only the methods listed on the Java Quick Reference are fair game on the exam. That means contains, indexOf, and isEmpty are not part of the required AP method set, even though they exist in real Java. Build your fluency around the methods the exam will actually test.

Key Takeaways

• An ArrayList has a dynamic size and stores object references, so it can grow and shrink while arrays cannot.
• The AP method set is size(), add(E obj), add(int index, E obj), get(int index), set(int index, E obj), and remove(int index).
• add(int index, E obj) shifts elements right and remove(int index) shifts elements left, which changes the indices of later elements.
• set and remove return the element that used to be there; add(E obj) returns true; add(int index, E obj) returns nothing.
• Use ArrayList<E> with a type, like ArrayList<String>, so the compiler catches type errors early.
• Valid indices run from 0 to size() - 1; going outside that range throws an IndexOutOfBoundsException.

Setting Up an ArrayList

ArrayList lives in the java.util package, so you need an import statement before you use it:

</>Java
import java.util.ArrayList;

The no-argument constructor builds an empty list. Always specify the element type with ArrayList<E>:

</>Java
ArrayList<String> names = new ArrayList<String>();

Writing ArrayList<String> instead of plain ArrayList lets the compiler find type errors while you write code, instead of letting them surface as run-time errors. The type parameter E stands for whatever element type you choose, so the parameter and return types of the methods match that type.

Because an ArrayList stores object references, the element type must be a class type. To store numbers you use the wrapper classes, such as ArrayList<Integer> or ArrayList<Double>.

The Required ArrayList Methods

These six methods are the ones on the Java Quick Reference, so they are the ones the exam expects you to know.

For add(int index, E obj), the index can be anywhere from 0 up to size(), inclusive. Adding at size() puts the element at the end. Inserting anywhere else moves the element currently at that position, and everything after it, one spot to the right, and the size goes up by 1.

For remove(int index), everything after the removed element slides one spot to the left, and the size goes down by 1.

Adding Elements

</>Java
import java.util.ArrayList;

public class AddingMethods {
    public static void main(String[] args) {
        ArrayList<String> playlist = new ArrayList<String>();

        // add(E obj) - appends to the end
        playlist.add("Song A");
        playlist.add("Song B");
        playlist.add("Song C");
        System.out.println("After basic adds: " + playlist);

        // add(int index, E obj) - inserts and shifts later elements right
        playlist.add(1, "New Song");
        System.out.println("After insertion: " + playlist);
    }
}

add("Song A") always lands at the end. add(1, "New Song") puts the new value at index 1 and shifts "Song B" and "Song C" to the right.

Accessing and Replacing Elements

</>Java
import java.util.ArrayList;

public class GradeManager {
    public static void main(String[] args) {
        ArrayList<Integer> grades = new ArrayList<Integer>();
        grades.add(85);
        grades.add(92);
        grades.add(78);
        grades.add(96);

        // get(int index) - reads without changing the list
        int firstGrade = grades.get(0);
        System.out.println("First grade: " + firstGrade);

        // set(int index, E obj) - replaces and returns the old value
        int oldGrade = grades.set(2, 88);  // changes 78 to 88
        System.out.println("Replaced " + oldGrade + " with 88");
        System.out.println("Updated grades: " + grades);

        // size() - how many elements
        System.out.println("Total grades: " + grades.size());
    }
}

get and size only read information, so they never change the list. set changes one element and hands back the value that used to be there, which is handy when you want to know what you replaced.

Removing Elements

</>Java
import java.util.ArrayList;

public class CartExample {
    public static void main(String[] args) {
        ArrayList<String> cart = new ArrayList<String>();
        cart.add("Apples");
        cart.add("Bread");
        cart.add("Milk");
        cart.add("Cookies");

        System.out.println("Original cart: " + cart);

        // remove(int index) - removes by position and returns that element
        String removedItem = cart.remove(0);
        System.out.println("Removed: " + removedItem);
        System.out.println("Cart after removal: " + cart);
        System.out.println("New size: " + cart.size());
    }
}

remove(0) takes out "Apples" and returns it, then slides "Bread", "Milk", and "Cookies" left so they now sit at indices 0, 1, and 2.

How to Use This on the AP Computer Science A Exam

Code Tracing

When you trace ArrayList code, keep a running picture of the list and its indices after every call. Write the list out and update it line by line.

• After add(int index, E obj), every element from that index onward moves up one index.
• After remove(int index), every later element moves down one index.
• Remember that set and remove return values you can store or print, while add(E obj) returns true and add(int index, E obj) returns nothing.

Free Response

For free-response code writing that uses an ArrayList of objects, you will often insert or delete elements while looping. When you remove an element, the next element slides into the current index, so a normal counter would skip it. Adjust your loop so you do not move past the element that just shifted into place. Be sure your indices stay between 0 and size() - 1 so you avoid an IndexOutOfBoundsException.

Common Trap

The exam frequently tests the difference between treating a number as an index and treating it as a value. Since the required remove method takes an int index, a call like remove(1) removes the element at index 1. Read each call carefully and confirm whether the argument is a position or something else.

Common Misconceptions

• remove(int index) removes the element at that index, not the value equal to that number. With ArrayList<Integer>, remove(1) removes whatever is at index 1.
• add(E obj) and add(int index, E obj) do not return the same thing. The append version returns true; the insert version returns nothing.
• Inserting or removing in the middle of a list is not free. Other elements shift, and their indices change, which is exactly what trips people up in loops.
• The valid indices are 0 through size() - 1. Using size() itself as a read index throws an IndexOutOfBoundsException, even though it is a legal position for add(int index, E obj).
• contains, indexOf, and isEmpty are real Java methods but are not in the AP required method set, so do not rely on them in your exam answers.
• Declaring ArrayList<String> names; does not create a list. You must assign new ArrayList<String>() before calling methods, or you get a NullPointerException.

Related AP Computer Science A Guides

• 4.11 2D Arrays
• 4.15 Sorting
• 4.1 Ethical and Social Implications
• 4.9 Traversing ArrayLists
• 4.5 Developing Algorithms Using Arrays
• 4.16 Recursion