ArrayList Methods

Hello there! It's Saavi. Today, we're diving into one of the most useful tools in your Java toolkit: the ArrayList.

Think back to standard arrays. They're like a row of lockers in a school hallway. Once the school is built, you can't just add more lockers in the middle of the row; the number is fixed. ArrayLists are different. They're more like a stack of foldable chairs. You can always bring in another chair or take one away. This ability to change size—what we call being mutable—is the ArrayList's superpower.

Setting Up Your First ArrayList

Before you can use an ArrayList, you need to do two things.

First, you must tell Java where to find the ArrayList code. It lives in a package called java.util, so you need an import statement at the very top of your file:

import java.util.ArrayList;

Second, you need to declare and create it. Here's where we see something new: the angle brackets <>.

ArrayList<String> groceryList = new ArrayList<String>();

This creates a new, empty ArrayList that is specifically designed to hold String objects. The <String> part is called a type parameter or generic.

This is where some students get confused. Why do we need <String>? Can't we just have a plain ArrayList? While you technically can, using the type parameter is a huge help. It tells the compiler, "Hey, I only ever plan to put String objects in this list." If you accidentally try to add a number, like groceryList.add(5);, the compiler will catch your mistake immediately. Without generics, that error would only pop up when you run the program, which is much harder to debug. Always use generics!

The Core Methods You Need to Know

The AP exam focuses on a handful of essential ArrayList methods. Let's walk through them using our groceryList example. These are all on your Java Quick Reference sheet.

1. Adding Elements: add()

There are two ways to add to an ArrayList.

• boolean add(E obj): This adds the object to the very end of the list.

  ArrayList<String> groceryList = new ArrayList<String>();
  groceryList.add("Milk");    // list is now ["Milk"]
  groceryList.add("Bread");   // list is now ["Milk", "Bread"]
  groceryList.add("Eggs");    // list is now ["Milk", "Bread", "Eggs"]

  This method technically returns true, but we almost always ignore that return value.

• void add(int index, E obj): This inserts the object at a specific position, shifting everything else to the right.

  Imagine our list is ["Milk", "Bread", "Eggs"]. The indices are 0, 1, and 2. If we want to add "Cereal" right after "Milk" (at index 1), we do this:

  groceryList.add(1, "Cereal"); // inserts "Cereal" at index 1

  The list is now ["Milk", "Cereal", "Bread", "Eggs"]. Notice how "Bread" and "Eggs" were pushed one spot to the right to make room.

2. Getting the Size: size()

This one is straightforward. It tells you how many items are currently in the list.

System.out.println(groceryList.size()); // Prints: 4

Remember, an empty list has a size of 0.

3. Accessing Elements: get()

To read an item from the list, you use get(index). Just like with arrays, indices start at 0.

String firstItem = groceryList.get(0); // "Milk"
String thirdItem = groceryList.get(2); // "Bread"

This is a classic spot for errors. The valid indices for an ArrayList are from 0 to size() - 1. If you try to get() an element at size() or higher, your program will crash with an IndexOutOfBoundsException.

4. Replacing Elements: set()

What if you want to swap an item? You use set(index, obj). This replaces the element at a given index with a new one.

Let's say we want to buy organic eggs instead. "Eggs" is at index 3.

groceryList.set(3, "Organic Eggs");
// list is now ["Milk", "Cereal", "Bread", "Organic Eggs"]

The set method also returns the element that was replaced. This can be useful.

String oldItem = groceryList.set(0, "Almond Milk"); // oldItem is now "Milk"
// list is now ["Almond Milk", "Cereal", "Bread", "Organic Eggs"]

5. Removing Elements: remove()

Finally, to take an item out, you use remove(index). This removes the element at the specified index and shifts everything to its right one spot to the left to fill the gap.

Let's remove "Cereal" (at index 1).

groceryList.remove(1);
// list is now ["Almond Milk", "Bread", "Organic Eggs"]

Just like set, remove also returns the element that was just removed.

String removedItem = groceryList.remove(1); // removedItem is now "Bread"
// list is now ["Almond Milk", "Organic Eggs"]
System.out.println(groceryList.size()); // Prints: 2

By mastering these five methods, you can perform almost any manipulation you need on a dynamic list of data.

Let's walk through a couple of examples to see these methods in action. It's like a play-by-play of what's happening inside the computer's memory.

ArrayList<String> chores = new ArrayList<String>();
chores.add("Clean room");
chores.add("Do laundry");
chores.add("Walk the dog");
chores.add(1, "Finish APUSH reading");
String replacedChore = chores.set(0, "Deep clean room");
chores.remove(2);

ArrayList<Integer> points = new ArrayList<Integer>();
points.add(2);    // Layup
points.add(3);    // Three-pointer
points.add(2);    // Another layup
points.set(0, 1); // Oops, it was a free throw
points.add(1, 1); // And another free throw
int lastScore = points.remove(points.size() - 1);

Ready to try on your own? Think carefully about how the list changes with each step.

Problem 1: Playlist Shuffle

Predict the final state of the playlist ArrayList and the value of the nextSong variable after this code runs.

ArrayList<String> playlist = new ArrayList<String>();
playlist.add("Solar Power");
playlist.add("Good Days");
playlist.add("Levitating");
playlist.set(1, "Blinding Lights");
playlist.add(0, "As It Was");
String nextSong = playlist.remove(2);

Hint: Draw out the list on a piece of paper. After each line of code, cross out the old list and write the new one, paying close attention to the indices.

Problem 2: Class Roster

You are given an ArrayList of student names. Write the single line of code that would replace the student at index 3, "Marcus", with a new student, "Sofia".

ArrayList<String> roster = new ArrayList<String>();
roster.add("Liam");
roster.add("Priya");
roster.add("Aaliyah");
roster.add("Marcus");
roster.add("Jordan");

// Your line of code here

Hint: Are you adding a new student or replacing an existing one? Which method does that?