Time estimate: 45 min.

7.2. ArrayList Methods¶

The following are the ArrayList methods that you need to know for the AP CSA exam. These are included on the AP CSA Java Quick Reference Sheet that you will receive during the exam so you do not need to memorize them. The E in the method headers below stands for the type of the element in the ArrayList; this type E can be any Object type. We will look at how these methods work below.

int size() returns the number of elements in the list
boolean add(E obj) appends obj to the end of the list and returns true
E remove(int index) removes the item at the index and shifts remaining items to the left (to a lower index)
void add(int index, E obj) moves any current objects at index or beyond to the right (to a higher index) and inserts obj at the index
E get(int index) returns the item in the list at the index
E set(int index, E obj) replaces the item at index with obj

7.2.1. `size()`¶

As we saw in the last lesson, you can get the number of items in a ArrayList using its size() method. The ArrayList starts out empty with a size of 0.

ArrayList<String> list = new ArrayList<String>();
System.out.println( list.size() );

Note

With arrays, you use the length field to get the number of items in the array. But, with an ArrayList you use the size() method to get the number of items in the ArrayList. You will not be penalized if you mix up length and size() in the CSA exam. The number of items in an empty ArrayList is 0.

7.2.2. `add(obj)`¶

You can add values to an ArrayList using the method add(obj) which will add the object to the end of the list, just like you would join the end of the line to board a bus.

Coding Exercise

Run the code below to see how the list changes as each object is added to the end. Notice that we added the same string to the list more than once. Lists can hold duplicate objects. Can you add your name to the list and then print out the list?

import java.util.*; // import all classes in this package.

public class listAdd1
{
    public static void main(String[] args)
    {
        ArrayList<String> nameList = new ArrayList<String>();
        nameList.add("Diego");
        System.out.println(nameList);
        nameList.add("Grace");
        System.out.println(nameList);
        nameList.add("Diego");
        System.out.println(nameList);
        System.out.println(nameList.size());
    }
}

====
import static org.junit.Assert.*;

import org.junit.*;

import java.io.*;

public class RunestoneTests extends CodeTestHelper
{
    public RunestoneTests()
    {
        super("listAdd1");
    }

@Test
    public void test1()
    {
        String output = getMethodOutput("main");
        String expect = "[Diego, Grace, Diego, Your name]";
        String searchString = "\\[Diego, Grace, Diego, [A-Za-z0-9 '-,]+\\]";

String[] lines = output.split("\n");
        String longest = lines[0];
        for (int i = 0; i < lines.length; i++)
        {
            if (lines[i].length() > longest.length())
            {
                 longest = lines[i];
            }
        }

boolean passed = output.matches("[\\s\\S]+" + searchString + "[\\s\\S]*");

passed = getResults(expect, longest, "Add your name to the list", passed);
        assertTrue(passed);
    }
}

When adding Integer objects to the list, you can use the Integer constructor like add(new Integer(5)) in Java version 7 which is used on the exam (although this is deprecated and no longer used in Java version 9) or you can just add the int value directly like add(5) in any Java version and it will be changed into an Integer object automatically. This is called autoboxing. When you pull an int value out of a list of Integers that is called unboxing.

ArrayList<Integer> list = new ArrayList<Integer>();
list.add(new Integer(5)); // this will only work in Java 7
list.add(5); // this will work in all Java versions

You can put any kind of objects into an ArrayList. Even instances of a class that you wrote. For example, here is an ArrayList of Students.

An example of an ArrayList of Student objects. Add a new student with your name and info in it.

import java.util.*;

public class StudentList
{
    // main method for testing
    public static void main(String[] args)
    {
        ArrayList<Student> roster = new ArrayList<Student>();
        roster.add(new Student("Skyler", "skyler@sky.com", 123456));
        roster.add(new Student("Ayanna", "ayanna@gmail.com", 789012));

System.out.println(roster);
    }
}

class Student
{
    private String name;
    private String email;
    private int id;

public Student(String initName, String initEmail, int initId)
    {
        name = initName;
        email = initEmail;
        id = initId;
    }

// toString() method
    public String toString()
    {
        return id + ": " + name + ", " + email;
    }
}

====
import static org.junit.Assert.*;

import org.junit.*;

import java.io.*;

public class RunestoneTests extends CodeTestHelper
{
    public RunestoneTests()
    {
        super("StudentList");
    }

@Test
    public void test1()
    {
        String output = getMethodOutput("main");
        String expect = "[123456: Skyler, skyler@sky.com, 789012: Ayanna, ayanna@gmail.com]";

boolean passed = getResults(expect, output, "main()", true);
        assertTrue(passed);
    }
}

7.2.3. `add(index,obj)`¶

There are actually two different add methods in the ArrayList class. The add(obj) method adds the passed object to the end of the list. The add(index,obj) method adds the passed object at the passed index, but first moves over any existing values to higher indices to make room for the new object.

Coding Exercise

What will the code below print out? Try figuring it out before running it. Remember that ArrayLists start at index 0 and that the add(index,obj) always has the index as the first argument.

import java.util.*; // import all classes in this package.

public class listAddInt2
{
    public static void main(String[] arts)
    {
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        list1.add(1);
        System.out.println(list1);
        // adds the number 2 to the end of the list
        list1.add(2);
        System.out.println(list1);
        // This will add the number 3 at index 1
        list1.add(1, 3);
        System.out.println(list1);
        // This will add the number 4 at index 1
        list1.add(1, 4);
        System.out.println(list1);
        System.out.println(list1.size());
    }
}

====
import static org.junit.Assert.*;

import org.junit.*;

import java.io.*;

public class RunestoneTests extends CodeTestHelper
{
    public RunestoneTests()
    {
        super("listAddInt2");
    }

@Test
    public void test1()
    {
        String output = getMethodOutput("main");
        String expect = "[1]\n[1, 2]\n[1, 3, 2]\n[1, 4, 3, 2]\n4\n";

boolean passed = getResults(expect, output, "main()", true);
        assertTrue(passed);
    }
}

Note

ArrayLists like arrays start numbering their elements from 0.

Check your understanding

7-2-4: What will print when the following code executes?

ArrayList<Integer> list1 = new ArrayList<Integer>();
list1.add(1);
list1.add(2);
list1.add(3);
list1.add(2, 4);
list1.add(5);
System.out.println(list1);

[1, 2, 3, 4, 5]
This would be true if all the add method calls were add(value), but at least one is not.
[1, 4, 2, 3, 5]
This would be true if it was add(1, 4)
[1, 2, 4, 3, 5]
The add(2, 4) will put the 4 at index 2, but first move the 3 to index 3.
[1, 2, 4, 5]
This would be true if the add(2, 4) replaced what was at index 2, but it actually moves the value currently at index 2 to index 3.

You can step through the code above by clicking on this Java Visualizer.

7-2-5: What will print when the following code executes?

ArrayList<String> list1 = new ArrayList<String>();
list1.add("Anaya");
list1.add("Layla");
list1.add("Sharrie");
list1.add(1, "Sarah");
System.out.println(list1);

["Anaya", "Sarah", "Layla", "Sharrie"]
The add(1, "Sarah") will move any current items to the right and then put "Sarah" at index 1.
["Anaya", "Layla", "Sharrie", "Sarah"]
This would be true if the last one was add("Sarah")
["Sarah", "Anaya", "Layla", "Sharrie"]
This would be true if the last one was add(0, "Sarah")
["Anaya", "Layla", "Sarah", "Sharrie"]
This would be true if the last one was add(2, "Sarah")

You can step through the code above by clicking on the following Java Visualizer.

7.2.4. `remove(index)`¶

You can also remove values from an ArrayList using the remove(index) method. It removes and returns the item at the given index. This will move all the other items over in the underlying array and decrease the size of the ArrayList by 1.

Coding Exercise

What will the following code print out? Try to guess before you run it. Were you surprised? Read the note below.

Note

The remove(int index) method will remove the object at the given index and shift left any values to the right of that index. It doesn’t remove the object that matches the integer value given. In the example above it doesn’t remove the value 1. It removes the value 2 at index 1.

7-2-7: What will print when the following code executes?

List<Integer> list1 = new ArrayList<Integer>();
list1.add(1);
list1.add(2);
list1.add(3);
list1.remove(2);
System.out.println(list1);

[2, 3]
This would be true if it was remove(0)
[1, 2, 3]
The remove will remove a value from the list, so this can't be correct.
[1, 2]
The 3 (at index 2) is removed
[1, 3]
This would be true if it was remove(1)

You can step through the code above by clicking on the following RemoveExample.

7.2.5. `get(index)` and `set(index, obj)`¶

You can get the object at an index using obj = listName.get(index) and set the object at an index using listName.set(index,obj). Both methods require that the index argument refer to an existing element of the list, i.e. the index must be greater than or equal to 0 and less than the size() of the list.

Notice that ArrayLists use get and set methods instead of the index operator that we use with arrays: array[index]. This is because ArrayList is a class with methods, not a built in type with special support in the language like arrays.

Coding Exercise

Try to guess what the code below will print before running it. Can you get the last element in the nameList to print it out? Can you set the first element in the list to your name and print out the list?

import java.util.*; // import all classes in this package.

public class listGetSet
{
    public static void main(String[] args)
    {
        ArrayList<String> nameList = new ArrayList<String>();
        nameList.add("Diego");
        nameList.add("Grace");
        nameList.add("Deja");
        System.out.println(nameList);
        System.out.println(nameList.get(0));
        System.out.println(nameList.get(1));
        nameList.set(1, "John");
        System.out.println(nameList);
    }
}

====
import static org.junit.Assert.*;

import org.junit.*;

import java.io.*;

public class RunestoneTests extends CodeTestHelper
{
    public RunestoneTests()
    {
        super("listGetSet");
    }

@Test
    public void test1()
    {
        boolean passed =
                checkCodeContainsRegex("nameList.set(0, \"Your name\")", "nameList.set(0, ");
        assertTrue(passed);
    }

@Test
    public void test2()
    {
        String output = getMethodOutput("main");
        String searchString = "Deja";

boolean passed =
                output.contains("\n" + searchString)
                        || output.matches("\\s+" + searchString + "\\s+");

passed = getResults("true", "" + passed, "Prints last item in list (Deja)", passed);
        assertTrue(passed);
    }
}

Check your understanding

7-2-9: What will print when the following code executes?

List<Integer> list1 = new ArrayList<Integer>();
list1.add(1);
list1.add(2);
list1.add(3);
list1.set(2, 4);
list1.add(2, 5);
list1.add(6);
System.out.println(list1);

[1, 2, 3, 4, 5]
The set will replace the item at index 2 so this can not be right.
[1, 2, 4, 5, 6]
The add with an index of 2 and a value of 5 adds the 5 at index 2 not 3. Remember that the first index is 0.
[1, 2, 5, 4, 6]
The set will change the item at index 2 to 4. The add of 5 at index 2 will move everything else to the right and insert 5. The last add will be at the end of the list.
[1, 5, 2, 4, 6]
The add with an index of 2 and a value of 5 adds the 5 at index 2 not 1. Remember that the first index is 0.

You can step through the code above by clicking on the following Example1.

7-2-10: What will print when the following code executes?

List<String> list1 = new ArrayList<String>();
list1.add("Anaya");
list1.add("Layla");
list1.add("Sharrie");
list1.set(1, "Destini");
list1.add(1, "Sarah");
System.out.println(list1);

["Sarah", "Destini", "Layla", "Sharrie"]
Remember that the first index is 0 not 1.
["Sarah", "Destini", "Anaya", "Layla", "Sharrie"]
set changes the value and the first index is 0 not 1.
["Anaya", "Sarah", "Sharrie"]
add at index 1 adds the new value at that index but moves right any existing values.
["Anaya", "Sarah", "Destini", "Sharrie"]
The list is first ["Anaya", "Layla", "Sharrie"] and then changes to ["Anaya", Destini", "Sharrie"] and then to ["Anaya", "Sarah", "Destini", "Sharrie"]

You can step through the code above by clicking on the following Example2.

7.2.6. Comparing arrays and `ArrayList`s¶

When do you use arrays and when do you use ArrayLists? Use an array when you want to store several items of the same type and you know how many items will be in the array and the items in the array won’t change in order or number. Use an ArrayList when you want to store several items of the same type and you don’t know how many items you will need in the list or when you want to remove items from the list or add items to the list while the program is running.

Here is a comparison of how to create arrays and ArrayLists:

// arrays must specify a size!
int[] highScores = new int[5];
String[] names = new String[5];

// ArrayLists are empty to start with
ArrayList<Integer> highScoreList = new ArrayList<Integer>();
ArrayList<String> nameList = new ArrayList<String>();

Here is a comparison of how to access and change elements in arrays and ArrayLists. Note that ArrayLists have a method size() instead of a length property, and ArrayLists use get/set methods instead of the index operator ([]).

Operation	array	ArrayList
length/size	array.length	list.size()
Access	value = array[index];	value = list.get(index);
Modify	array[index] = value;	list.set(index,value);

Note that the ArrayList methods add and remove do not have a simple equivalent in arrays because they change the number of elements in the list and may shift the positions of other elements.

Here is a comparison handout of the basic operations to access 1-dimensional and 2-dimensional arrays (which we will see in the next unit), ArrayLists, and Strings made by AP CSA teacher Sam Procopio of Bishop Blanchet High School.

7.2.7. Programming Challenge : Array to ArrayList¶

Rewrite the following code that uses an array to use an ArrayList instead. In the comments write why you think an ArrayList is a better data structure to use than an array for this problem.

import java.util.*;

public class ToDoList
{
    public static void main(String[] args)
    {
        // Rewrite this code to use an ArrayList instead of an array
        String[] toDoList = new String[3];
        toDoList[0] = "Do homework";
        toDoList[1] = "Help make dinner";
        toDoList[2] = "Call grandma";

// changing element 1
        toDoList[1] = "Order pizza";

System.out.println(toDoList.length + " things to do!");
        System.out.println("Here's the first thing to do: " + toDoList[0]);

// remove item 0 and move everything down
        //  (this can be done in one method call with ArrayList)
        toDoList[0] = toDoList[1];
        toDoList[1] = toDoList[2];
        toDoList[2] = "";

System.out.println("Here's the next thing to do: " + toDoList[0]);

// Why is an ArrayList better than an array for a toDoList?
        // Answer:
    }
}

====
import static org.junit.Assert.*;

import org.junit.*;

import java.io.*;

public class RunestoneTests extends CodeTestHelper
{
    public RunestoneTests()
    {
        super("ToDoList");
    }

@Test
    public void test1()
    {
        String output = getMethodOutput("main");
        String expect =
                "3 things to do!\n"
                    + "Here's the first thing to do: Do homework\n"
                    + "Here's the next thing to do: Order pizza";

boolean passed = getResults(expect, output, "Output is the same");
        assertTrue(passed);
    }

@Test
    public void test2()
    {
        String output = removeSpaces(getCode());
        String expect = "ArrayList<String>";

boolean passed = output.contains(expect);

passed = getResults("true", "" + passed, "Declare ArrayList", passed);
        assertTrue(passed);
    }

@Test
    public void test3()
    {
        String expect = "[*]";

boolean passed = checkCodeNotContains(expect);
        assertTrue(passed);
    }
}

7.2.8. Summary¶

The following ArrayList methods, including what they do and when they are used, are part of the Java Quick Reference:
- int size() : Returns the number of elements in the list
- boolean add(E obj) : Appends obj to end of list; returns true
- void add(int index, E obj) : Inserts obj at position index (0 <= index <= size), moving elements at position index and higher to the right (adds 1 to their indices) and adds 1 to size
- remove(int index) — Removes element from position index, moving elements at position index + 1 and higher to the left (subtracts 1 from their indices) and subtracts 1 from size; returns the element formerly at position index
- E get(int index) : Returns the element at position index in the list
- E set(int index, E obj) : Replaces the element at position index with obj; returns the element formerly at position index

You have attempted of activities on this page

7.2. ArrayList Methods¶

7.2.1. size()¶

7.2.2. add(obj)¶

7.2.3. add(index,obj)¶

7.2.4. remove(index)¶

7.2.5. get(index) and set(index, obj)¶

7.2.6. Comparing arrays and ArrayLists¶

7.2.7. Programming Challenge : Array to ArrayList¶

7.2.8. Summary¶

7.2.1. `size()`¶

7.2.2. `add(obj)`¶

7.2.3. `add(index,obj)`¶

7.2.4. `remove(index)`¶

7.2.5. `get(index)` and `set(index, obj)`¶

7.2.6. Comparing arrays and `ArrayList`s¶