ArrayList Methods

Picture an app that keeps a grocery list. When you open it, the list is empty. During the week you add items, cross some off, and squeeze a forgotten item into the middle. Nobody knows ahead of time how many items there will be.

An array from Topic 4.3 is a poor fit for this job. Its length is set when it is created and can never change. If you make an array of 10 items and need an 11th, you are stuck: you would have to build a bigger array and copy everything over. And removing an item from the middle of an array leaves a gap that you would have to close by hand.

Java has a class built for lists that change: ArrayList. An ArrayList object is a list of elements, kept in order, that can grow and shrink while the program runs. You can add an element, and the list gets one longer. You can remove an element, and the list gets one shorter, with no gap left behind. Because its size can change, we say an ArrayList is mutable in size. (An array’s elements can change, but its length cannot; an ArrayList can change both.)

Importing the class

String, Math, Integer, and Double live in a package named java.lang, which every Java program can use automatically (Topic 1.15). ArrayList lives in a different package, java.util (short for “utilities”), the same package as Scanner. To use a class from any package other than java.lang, you must tell Java where to find it with an import statement at the very top of the file, before the class. You wrote one in Topic 1.4, import java.util.Scanner;, and ArrayList needs the same kind of line:

import java.util.ArrayList;

Read it as “bring in the class ArrayList from the package java.util.” Without this line, Java has never heard of ArrayList.

Declaring and constructing the list

When you create an ArrayList, you also say what type of element it will hold, written in angle brackets after the class name. Here is a list that holds Strings:

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

The type in the angle brackets is called the type parameter. Java’s documentation writes the class as ArrayList<E>, where E stands for “the type of the elements” and gets replaced by a real type, such as String, when you write your code. A class that takes a type parameter like this is called a generic class. You will see in 4.8.7 why stating the type matters so much.

Notice what the constructor does not take: a size. With an array you wrote new String[10] and got 10 slots. An ArrayList starts with no elements at all and grows only as you add them. (Java also lets you shorten the right side to new ArrayList<>(), leaving the type out of the second pair of brackets because it is already on the left. Both forms work; this guide writes the type both times.)

import java.util.ArrayList;

public class EmptyList
{
    public static void main(String[] args)
    {
        ArrayList<String> groceries = new ArrayList<String>();
        System.out.println(groceries.size());
        System.out.println(groceries);
    }
}

0
[]

Now vary the element type. The type parameter can be any class: String, Double, Integer, or a class you wrote yourself in Unit 3.

import java.util.ArrayList;

public class EmptyTwoLists
{
    public static void main(String[] args)
    {
        ArrayList<String> names = new ArrayList<String>();
        ArrayList<Double> temperatures = new ArrayList<Double>();
        System.out.println(names.size());
        System.out.println(temperatures.size());
        System.out.println(temperatures);
    }
}

0
0
[]

public class MissingImport
{
    public static void main(String[] args)
    {
        ArrayList<String> groceries = new ArrayList<String>();
        System.out.println(groceries.size());
    }
}

MissingImport.java:5: error: cannot find symbol
        ArrayList<String> groceries = new ArrayList<String>();
        ^
  symbol:   class ArrayList
  location: class MissingImport

An empty list is a start, but a grocery list needs items. The simplest way to put an element in a list is to tack it onto the end, the way you write a new item at the bottom of a paper list.

The method add(E obj) does exactly that: it appends obj to the end of the list, and the list’s size goes up by 1. The E in the header is the type parameter from 4.8.1, so for an ArrayList<String>, add takes a String. Its full header is boolean add(E obj): it returns true every time. The return value exists for reasons outside this course, so you will almost always call add as a statement on its own and ignore what it returns.

The method int size() returns how many elements the list holds right now. Because elements come and go, size() can give a different answer each time you call it.

import java.util.ArrayList;

public class AddToEnd
{
    public static void main(String[] args)
    {
        ArrayList<String> groceries = new ArrayList<String>();
        groceries.add("milk");
        System.out.println(groceries.size());
        groceries.add("eggs");
        groceries.add("bread");
        System.out.println(groceries.size());
        System.out.println(groceries);
    }
}

1
3
[milk, eggs, bread]

The next example changes two things: it adds a value that is already in the list, and it prints what add returns.

import java.util.ArrayList;

public class AddDuplicates
{
    public static void main(String[] args)
    {
        ArrayList<String> orders = new ArrayList<String>();
        orders.add("taco");
        orders.add("salad");
        System.out.println(orders.add("taco"));
        System.out.println(orders);
        System.out.println(orders.size());
    }
}

true
[taco, salad, taco]
3

You now know three different ways Java asks “how many?”, and they are easy to mix up:

import java.util.ArrayList;

public class SizeNotLength
{
    public static void main(String[] args)
    {
        ArrayList<String> groceries = new ArrayList<String>();
        groceries.add("milk");
        System.out.println(groceries.length);
        System.out.println(groceries.length());
    }
}

SizeNotLength.java:9: error: cannot find symbol
        System.out.println(groceries.length);
                                    ^
SizeNotLength.java:10: error: cannot find symbol
        System.out.println(groceries.length());
                                    ^

import java.util.ArrayList;

public class AddTrace
{
    public static void main(String[] args)
    {
        ArrayList<String> pets = new ArrayList<String>();
        System.out.println(pets.size());
        pets.add("cat");
        pets.add("dog");
        System.out.println(pets.size());
        pets.add("cat");
        pets.add("fish");
        System.out.println(pets.size());
        System.out.println(pets);
    }
}

0
2
4
[cat, dog, cat, fish]

A list is only useful if you can look at what is in it. Just like an array (Topic 4.3), each element of an ArrayList has a position number called its index. The first element is at index 0, the next at index 1, and so on. The last element is at index size() - 1, one less than the number of elements, because counting started at 0 instead of 1.

Here is the grocery list from 4.8.2 with its indexes:

index:     0       1       2
value:  "milk"  "eggs"  "bread"

There are 3 elements, so the valid indexes are 0, 1, and 2. There is no index 3.

With an array you would write groceries[1], but square brackets do not work on an ArrayList, because it is an object, not an array. Instead you call the method E get(int index), which returns the element at that index. The return type is E, the list’s element type, so on an ArrayList<String>, get hands back a String. That means you can store the result in a String variable, or call a String method on it right away.

get only looks. It does not remove or change anything, and the size stays the same.

import java.util.ArrayList;

public class GetByIndex
{
    public static void main(String[] args)
    {
        ArrayList<String> groceries = new ArrayList<String>();
        groceries.add("milk");
        groceries.add("eggs");
        groceries.add("bread");
        System.out.println(groceries.get(0));
        System.out.println(groceries.get(2));
        String middle = groceries.get(1);
        System.out.println(middle.toUpperCase());
        System.out.println(groceries.size());
    }
}

milk
bread
EGGS
3

Because the last index is always size() - 1, you can reach the last element without knowing how long the list is. The next example uses that idea while the list grows.

import java.util.ArrayList;

public class GetLast
{
    public static void main(String[] args)
    {
        ArrayList<String> songs = new ArrayList<String>();
        songs.add("Rain");
        songs.add("Glow");
        System.out.println(songs.get(songs.size() - 1));
        songs.add("Tides");
        songs.add("Ember");
        System.out.println(songs.get(songs.size() - 1));
        System.out.println(songs.get(1).length());
    }
}

Glow
Ember
4

import java.util.ArrayList;

public class GetPastEnd
{
    public static void main(String[] args)
    {
        ArrayList<String> groceries = new ArrayList<String>();
        groceries.add("milk");
        groceries.add("eggs");
        groceries.add("bread");
        System.out.println(groceries.get(2));
        System.out.println(groceries.get(3));
    }
}

bread
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index 3 out of bounds for length 3
	at GetPastEnd.main(GetPastEnd.java:12)

import java.util.ArrayList;

public class GetTrace
{
    public static void main(String[] args)
    {
        ArrayList<String> cities = new ArrayList<String>();
        cities.add("Lima");
        cities.add("Oslo");
        cities.add("Cairo");
        cities.add("Pune");
        String pick = cities.get(cities.size() - 2);
        System.out.println(pick);
        System.out.println(cities.get(1).substring(0, 2));
        System.out.println(cities.get(0).length() + cities.size());
    }
}

Cairo
Os
8

Suppose your chore list says wash, dry, fold, and you decide to iron instead of dry. You do not want a fourth chore; you want to cross out dry and write iron in its place. With an array, you would write chores[1] = "iron";. An ArrayList again uses a method instead of square brackets.

The method E set(int index, E obj) replaces the element at index with obj. The list keeps the same size, and every other element stays where it was. As a bonus, set returns the element that used to be at that index, so you can keep the old value if you need it. (If you do not need it, call set as a statement and ignore the result.)

Because set replaces an element that already exists, the index must be a valid index for get: from 0 to size() - 1.

import java.util.ArrayList;

public class SetReplace
{
    public static void main(String[] args)
    {
        ArrayList<String> chores = new ArrayList<String>();
        chores.add("wash");
        chores.add("dry");
        chores.add("fold");
        String old = chores.set(1, "iron");
        System.out.println(old);
        System.out.println(chores);
        System.out.println(chores.size());
    }
}

dry
[wash, iron, fold]
3

Now use that return value for something. Swapping two elements is a classic job: with only set and get, you might worry that the first set destroys a value before you can move it. The returned old element solves that.

import java.util.ArrayList;

public class SetSwap
{
    public static void main(String[] args)
    {
        ArrayList<String> lineup = new ArrayList<String>();
        lineup.add("Ava");
        lineup.add("Ben");
        lineup.add("Cal");
        String moved = lineup.set(0, lineup.get(2));
        lineup.set(2, moved);
        System.out.println(lineup);
    }
}

[Cal, Ben, Ava]

import java.util.ArrayList;

public class SetPastEnd
{
    public static void main(String[] args)
    {
        ArrayList<String> chores = new ArrayList<String>();
        chores.add("wash");
        chores.add("dry");
        chores.add("fold");
        System.out.println(chores);
        chores.set(3, "iron");
        System.out.println(chores);
    }
}

[wash, dry, fold]
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index 3 out of bounds for length 3
	at SetPastEnd.main(SetPastEnd.java:12)

import java.util.ArrayList;

public class SetTrace
{
    public static void main(String[] args)
    {
        ArrayList<String> seats = new ArrayList<String>();
        seats.add("Ira");
        seats.add("Jo");
        seats.add("Kim");
        String first = seats.set(2, "Lee");
        String second = seats.set(0, first);
        System.out.println(first);
        System.out.println(second);
        System.out.println(seats);
    }
}

Kim
Ira
[Kim, Jo, Lee]

Back to the grocery app: you forgot an item and want it near the top, not at the bottom. Or a friend joins a line of people, and you let them in at second place. add(obj) always goes to the end, and set overwrites someone. You need a way to squeeze an element in.

There is a second add method with two parameters: void add(int index, E obj). It inserts obj at position index. To make room, the element that was at index, and every element after it, moves one place to the right: each one’s index goes up by 1. The size goes up by 1. Nothing is lost or overwritten. This version returns nothing (void).

Think of people standing in numbered spots. When someone cuts in at spot 1, the person at spot 1 steps to spot 2, the person at spot 2 steps to spot 3, and so on to the end of the line.

For this method, the valid indexes are 0 through size(), one more than for get and set. Index size() is allowed because inserting there means “after the last element,” which is the end of the list; nothing has to move. Any index larger than size() would leave a gap, so Java refuses it.

import java.util.ArrayList;

public class InsertMiddle
{
    public static void main(String[] args)
    {
        ArrayList<String> line = new ArrayList<String>();
        line.add("Ana");
        line.add("Ben");
        line.add("Cy");
        line.add(1, "Dev");
        System.out.println(line);
        System.out.println(line.get(2));
        System.out.println(line.size());
    }
}

index:    0      1      2
value:  "Ana"  "Ben"  "Cy"

index:    0      1      2      3
value:  "Ana"  "Dev"  "Ben"  "Cy"

[Ana, Dev, Ben, Cy]
Ben
4

Now vary the index: insert at the very front, at the very end, and then one past the end.

import java.util.ArrayList;

public class InsertEnds
{
    public static void main(String[] args)
    {
        ArrayList<String> line = new ArrayList<String>();
        line.add("Ana");
        line.add("Ben");
        line.add("Cy");
        line.add(0, "Eve");
        System.out.println(line);
        line.add(line.size(), "Flo");
        System.out.println(line);
        line.add(line.size() + 1, "Gus");
        System.out.println(line);
    }
}

[Eve, Ana, Ben, Cy]
[Eve, Ana, Ben, Cy, Flo]
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 6, Size: 5
	at InsertEnds.main(InsertEnds.java:15)

The two methods that take an index and an element, set and the two-parameter add, look almost alike, but they do very different things:

import java.util.ArrayList;

public class SetVsInsert
{
    public static void main(String[] args)
    {
        ArrayList<String> replaced = new ArrayList<String>();
        replaced.add("Ana");
        replaced.add("Ben");
        replaced.add("Cy");
        replaced.set(1, "Dev");
        System.out.println(replaced);

        ArrayList<String> inserted = new ArrayList<String>();
        inserted.add("Ana");
        inserted.add("Ben");
        inserted.add("Cy");
        inserted.add(1, "Dev");
        System.out.println(inserted);
    }
}

[Ana, Dev, Cy]
[Ana, Dev, Ben, Cy]

import java.util.ArrayList;

public class InsertTrace
{
    public static void main(String[] args)
    {
        ArrayList<String> stops = new ArrayList<String>();
        stops.add("Park");
        stops.add("Mall");
        stops.add(1, "Zoo");
        stops.add(0, "Depot");
        stops.add(stops.size(), "Bay");
        System.out.println(stops);
        System.out.println(stops.get(2));
    }
}

[Depot, Park, Zoo, Mall, Bay]
Zoo

The last thing a grocery list needs is a way to cross items off. When an item is gone, you want the list to close up so there is no hole. With an array that meant shifting elements yourself; an ArrayList does it for you.

The method E remove(int index) removes the element at index. Every element after it moves one place to the left: each one’s index goes down by 1. The size goes down by 1. Like set, it returns the element that was removed, so you can use it after it leaves the list.

Insert and remove are mirror images: add(index, obj) shifts later elements right to open a space, and remove(index) shifts them left to close one. Because remove takes away an element that exists, its valid indexes are 0 to size() - 1, the same as get and set. An index outside that range throws an IndexOutOfBoundsException.

import java.util.ArrayList;

public class RemoveShift
{
    public static void main(String[] args)
    {
        ArrayList<String> line = new ArrayList<String>();
        line.add("Ana");
        line.add("Dev");
        line.add("Ben");
        line.add("Cy");
        String gone = line.remove(1);
        System.out.println(gone);
        System.out.println(line);
        System.out.println(line.get(1));
        System.out.println(line.size());
    }
}

index:    0      1      2      3
value:  "Ana"  "Dev"  "Ben"  "Cy"

index:    0      1      2
value:  "Ana"  "Ben"  "Cy"

Dev
[Ana, Ben, Cy]
Ben
3

Next, vary what happens to the removed element. Since remove returns it, you can pass it straight to another method, such as add on a different list.

import java.util.ArrayList;

public class ServeLine
{
    public static void main(String[] args)
    {
        ArrayList<String> waiting = new ArrayList<String>();
        waiting.add("Ana");
        waiting.add("Ben");
        waiting.add("Cy");
        ArrayList<String> served = new ArrayList<String>();
        served.add(waiting.remove(0));
        served.add(waiting.remove(0));
        System.out.println(waiting);
        System.out.println(served);
        waiting.remove(waiting.size() - 1);
        System.out.println(waiting);
        System.out.println(waiting.size());
    }
}

[Cy]
[Ana, Ben]
[]
0

import java.util.ArrayList;

public class RemoveTwoWrong
{
    public static void main(String[] args)
    {
        ArrayList<String> team = new ArrayList<String>();
        team.add("Ana");
        team.add("Ben");
        team.add("Cy");
        team.add("Dev");
        team.add("Eve");
        team.remove(1);
        team.remove(3);
        System.out.println(team);
    }
}

[Ana, Cy, Dev]

import java.util.ArrayList;

public class RemoveTwoFixed
{
    public static void main(String[] args)
    {
        ArrayList<String> team = new ArrayList<String>();
        team.add("Ana");
        team.add("Ben");
        team.add("Cy");
        team.add("Dev");
        team.add("Eve");
        team.remove(3);
        team.remove(1);
        System.out.println(team);
    }
}

[Ana, Cy, Eve]

import java.util.ArrayList;

public class RemoveTrace
{
    public static void main(String[] args)
    {
        ArrayList<String> books = new ArrayList<String>();
        books.add("Holes");
        books.add("Wonder");
        books.add("Dune");
        books.add("Matilda");
        String a = books.remove(0);
        String b = books.remove(books.size() - 1);
        books.add(1, a);
        System.out.println(b);
        System.out.println(books);
        System.out.println(books.get(1));
    }
}

Matilda
[Wonder, Holes, Dune]
Holes

import java.util.ArrayList;

public class CleanupBug
{
    public static void main(String[] args)
    {
        ArrayList<String> tasks = new ArrayList<String>();
        tasks.add("email");
        tasks.add("lunch");
        tasks.add("report");
        tasks.add("nap");
        tasks.remove(1);
        tasks.remove(2);
        System.out.println(tasks);
    }
}

        tasks.remove(2);
        tasks.remove(1);

        tasks.remove(1);
        tasks.remove(1);

You have used the type parameter since 4.8.1, writing <String> without much thought. Now look at why it is there, and what happens when you want a list of numbers.

The compiler checks the element type

When you write ArrayList<String>, every method that takes or returns an element uses String in place of E. So for that list, add expects a String, set expects a String and returns a String, and get and remove return Strings. The compiler knows this, so it can catch a wrong type before the program ever runs.

import java.util.ArrayList;

public class WrongType
{
    public static void main(String[] args)
    {
        ArrayList<String> names = new ArrayList<String>();
        names.add("Rosa");
        names.add(42);
        int letters = names.get(0);
        System.out.println(letters);
    }
}

WrongType.java:9: error: incompatible types: int cannot be converted to String
        names.add(42);
                  ^
WrongType.java:10: error: incompatible types: String cannot be converted to int
        int letters = names.get(0);
                               ^

Java does let you write ArrayList with no type parameter at all, as in ArrayList list = new ArrayList();. Such a list accepts any kind of object, so the compiler cannot check what goes in or what comes out. A mistake like line 9 would compile, and the problem would only surface later, as an error while the program runs, which is harder to track down. That is why ArrayList<E> with a real type is always preferred: it lets the compiler find errors that would otherwise show up only at run time. Always write the type parameter.

Lists of numbers need wrapper classes

An ArrayList holds object references, not primitive values. (You will see what that means for objects in 4.8.8.) The type parameter must therefore be a class, never a primitive type such as int or double:

import java.util.ArrayList;

public class IntList
{
    public static void main(String[] args)
    {
        ArrayList<int> scores = new ArrayList<int>();
        scores.add(88);
        System.out.println(scores);
    }
}

IntList.java:7: error: unexpected type
        ArrayList<int> scores = new ArrayList<int>();
                  ^
  required: reference
  found:    int

The message says the compiler needed a reference type and found the primitive int (and it reports the same error for the second <int>). This is exactly the job the wrapper classes from Topic 4.7 were made for. Use Integer for whole numbers and Double for decimals:

ArrayList<Integer> scores = new ArrayList<Integer>();

Then autoboxing and unboxing from Topic 4.7 do the conversions for you. When you pass an int to add, which expects an Integer, Java boxes it into an Integer automatically. When you assign the Integer that get returns to an int variable, Java unboxes it.

import java.util.ArrayList;

public class ScoresList
{
    public static void main(String[] args)
    {
        ArrayList<Integer> scores = new ArrayList<Integer>();
        scores.add(88);
        scores.add(92);
        scores.add(75);
        int first = scores.get(0);
        int total = scores.get(1) + scores.get(2);
        System.out.println(first);
        System.out.println(total);
        int oldScore = scores.set(2, 80);
        System.out.println(oldScore);
        System.out.println(scores);
    }
}

88
167
75
[88, 92, 80]

Double works the same way. This example averages two temperatures and inserts a third at the front.

import java.util.ArrayList;

public class TemperatureList
{
    public static void main(String[] args)
    {
        ArrayList<Double> temps = new ArrayList<Double>();
        temps.add(71.5);
        temps.add(68.0);
        double average = (temps.get(0) + temps.get(1)) / temps.size();
        System.out.println(average);
        temps.add(0, 75.25);
        System.out.println(temps);
    }
}

69.75
[75.25, 71.5, 68.0]

import java.util.ArrayList;

public class RemoveIndexNotValue
{
    public static void main(String[] args)
    {
        ArrayList<Integer> nums = new ArrayList<Integer>();
        nums.add(40);
        nums.add(2);
        nums.add(7);
        nums.add(1);
        int removed = nums.remove(1);
        System.out.println(removed);
        System.out.println(nums);
    }
}

2
[40, 7, 1]

import java.util.ArrayList;

public class PricesBug
{
    public static void main(String[] args)
    {
        ArrayList<Double> prices = new ArrayList<Double>();
        prices.add(2.5);
        prices.add(3);
        System.out.println(prices);
    }
}

PricesBug.java:9: error: incompatible types: int cannot be converted to Double
        prices.add(3);
                   ^

        prices.add(3.0);

import java.util.ArrayList;

public class NumbersTrace
{
    public static void main(String[] args)
    {
        ArrayList<Integer> laps = new ArrayList<Integer>();
        laps.add(5);
        laps.add(3);
        laps.add(0, 9);
        int gone = laps.remove(2);
        int changed = laps.set(0, gone + laps.get(1));
        System.out.println(gone);
        System.out.println(changed);
        System.out.println(laps);
    }
}

3
9
[8, 5]

In Topic 3.6 you learned that a variable of a class type holds a reference to an object, like an address, and that copying the variable copies the address, not the object. An ArrayList follows the same rule. Each element of a list is a reference. When you add an object, the list stores a copy of the reference, so the list and your variable now point to the same object. No copy of the object is made.

This matters as soon as the objects can change. Here is a Player class from Unit 3 with a method that changes the player’s points. (Java allows only one public class per file, so the helper class here leaves off public; in a real project each class gets its own file.)

import java.util.ArrayList;

class Player
{
    private String name;
    private int points;

    public Player(String name, int points)
    {
        this.name = name;
        this.points = points;
    }

    public String getName()
    {
        return name;
    }

    public int getPoints()
    {
        return points;
    }

    public void addPoints(int amount)
    {
        points = points + amount;
    }
}

public class TeamRefs
{
    public static void main(String[] args)
    {
        ArrayList<Player> team = new ArrayList<Player>();
        Player kai = new Player("Kai", 10);
        team.add(kai);
        team.add(new Player("Mo", 4));
        kai.addPoints(5);
        System.out.println(team.get(0).getPoints());
        team.get(0).addPoints(3);
        System.out.println(kai.getPoints());
        System.out.println(team.get(1).getName());
    }
}

kai  ─────────────────────►  Player "Kai", 10
team ──► index 0: ref ────►  (the same Player as kai)
         index 1: ref ────►  Player "Mo", 4

15
18
Mo

Now vary two things: add the same reference twice, and use set to replace a player. set replaces the reference stored in the list; it does not destroy the old object, and it returns a reference to it.

import java.util.ArrayList;

class Player
{
    private String name;
    private int points;

    public Player(String name, int points)
    {
        this.name = name;
        this.points = points;
    }

    public String getName()
    {
        return name;
    }

    public int getPoints()
    {
        return points;
    }

    public void addPoints(int amount)
    {
        points = points + amount;
    }
}

public class SetOldPlayer
{
    public static void main(String[] args)
    {
        ArrayList<Player> team = new ArrayList<Player>();
        Player star = new Player("Kai", 10);
        team.add(star);
        team.add(star);
        team.get(1).addPoints(4);
        System.out.println(team.get(0).getPoints());
        Player benched = team.set(0, new Player("Lu", 0));
        System.out.println(benched.getName());
        System.out.println(benched.getPoints());
        System.out.println(team.get(0).getName());
        System.out.println(team.get(1).getName());
    }
}

14
Kai
14
Lu
Kai

import java.util.ArrayList;

public class StringReassign
{
    public static void main(String[] args)
    {
        ArrayList<String> groceries = new ArrayList<String>();
        String item = "milk";
        groceries.add(item);
        item = "oat milk";
        System.out.println(item);
        System.out.println(groceries);
    }
}

oat milk
[milk]

import java.util.ArrayList;

class Player
{
    private String name;
    private int points;

    public Player(String name, int points)
    {
        this.name = name;
        this.points = points;
    }

    public String getName()
    {
        return name;
    }

    public int getPoints()
    {
        return points;
    }

    public void addPoints(int amount)
    {
        points = points + amount;
    }
}

public class RefsTrace
{
    public static void main(String[] args)
    {
        ArrayList<Player> squad = new ArrayList<Player>();
        Player a = new Player("Rin", 2);
        Player b = new Player("Sol", 6);
        squad.add(a);
        squad.add(b);
        squad.add(a);
        a.addPoints(1);
        squad.get(1).addPoints(10);
        Player out = squad.remove(0);
        out.addPoints(5);
        System.out.println(squad.get(0).getPoints());
        System.out.println(squad.get(1).getPoints());
        System.out.println(squad.size());
    }
}

16
8
2

A playlist is a natural ArrayList: songs are added, one can be bumped up to play next, and skipping a song sends it to the back. This Playlist class keeps its songs in a private ArrayList<String> instance variable and uses every method from the chapter. Before reading the trace, predict all five lines of output.

import java.util.ArrayList;

class Playlist
{
    private ArrayList<String> songs;

    public Playlist()
    {
        songs = new ArrayList<String>();
    }

    public void addSong(String title)
    {
        songs.add(title);
    }

    public void playNext(String title)
    {
        songs.add(1, title);
    }

    public String skip()
    {
        String skipped = songs.remove(0);
        songs.add(skipped);
        return skipped;
    }

    public String nowPlaying()
    {
        return songs.get(0);
    }

    public int getCount()
    {
        return songs.size();
    }

    public void show()
    {
        System.out.println(songs);
    }
}

public class PlaylistDemo
{
    public static void main(String[] args)
    {
        Playlist trip = new Playlist();
        trip.addSong("Rain");
        trip.addSong("Glow");
        trip.addSong("Tides");
        trip.playNext("Ember");
        trip.show();
        System.out.println(trip.skip());
        System.out.println(trip.nowPlaying());
        trip.show();
        System.out.println(trip.getCount());
    }
}

[Rain, Ember, Glow, Tides]
Rain
Ember
[Ember, Glow, Tides, Rain]
4

The ArrayList methods look alike, and the most common errors come from mixing them up or from using an index that is out of range. Use this table as a quick lookup:

An index outside the valid range throws an IndexOutOfBoundsException when the program runs.

• An ArrayList is an ordered list that can grow and shrink. It is in the java.util package, so a file that uses it needs import java.util.ArrayList;. The constructor new ArrayList<String>() makes an empty list.
• ArrayList<E> names the element type. The methods use that type for their parameters and return values, so the compiler can catch a wrong type before the program runs. Always write the type; numbers go in ArrayList<Integer> or ArrayList<Double>, with autoboxing and unboxing doing the conversions.
• size() counts the elements, add(obj) appends, get(i) returns an element, and set(i, obj) replaces one and returns the old element.
• add(i, obj) inserts and shifts later elements right; remove(i) removes, shifts later elements left, and returns the removed element. Either one changes the indexes of every later element.
• Indexes run from 0 to size() - 1 (up to size() for inserting). Any other index throws an IndexOutOfBoundsException.
• A list holds references to objects, so changing an object through the list or through another variable changes the same object.

import java.util.ArrayList;

public class MixedOps
{
    public static void main(String[] args)
    {
        ArrayList<String> colors = new ArrayList<String>();
        colors.add("red");
        colors.add("blue");
        colors.add("green");
        colors.add(1, "pink");
        String x = colors.set(2, "gold");
        String y = colors.remove(0);
        colors.add(y.toUpperCase());
        System.out.println(x + " " + y);
        System.out.println(colors);
        System.out.println(colors.get(colors.size() - 2));
    }
}

blue red
[pink, gold, green, RED]
green

import java.util.ArrayList;

public class LastNameBug
{
    public static void main(String[] args)
    {
        ArrayList<String> signups = new ArrayList<String>();
        signups.add("Ada");
        signups.add("Grace");
        signups.add("Alan");
        System.out.println(signups.size());
        String newest = signups.get(signups.size());
        System.out.println(newest);
    }
}

3
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index 3 out of bounds for length 3
	at LastNameBug.main(LastNameBug.java:12)

        String newest = signups.get(signups.size() - 1);

import java.util.ArrayList;

public class RemoveThenGet
{
    public static void main(String[] args)
    {
        ArrayList<Integer> vals = new ArrayList<Integer>();
        vals.add(10);
        vals.add(20);
        vals.add(30);
        int result = vals.remove(1) + vals.get(1);
        System.out.println(result);
        System.out.println(vals);
    }
}

import java.util.ArrayList;

public class ClubRoster
{
    public static void addHonor(ArrayList<String> roster, String name)
    {
        roster.add(0, name);
    }

    public static void main(String[] args)
    {
        ArrayList<String> club = new ArrayList<String>();
        club.add("Ivy");
        club.add("Max");
        addHonor(club, "Zoe");
        ArrayList<String> same = club;
        same.remove(club.size() - 1);
        System.out.println(club);
        System.out.println(same.size());
    }
}

[Zoe, Ivy]
2

import java.util.ArrayList;

class Playlist
{
    private ArrayList<String> songs;

    public Playlist()
    {
        songs = new ArrayList<String>();
    }

    public void addSong(String title)
    {
        songs.add(title);
    }

    public void playNext(String title)
    {
        songs.add(1, title);
    }

    public String skip()
    {
        String skipped = songs.remove(0);
        songs.add(skipped);
        return skipped;
    }

    public String nowPlaying()
    {
        return songs.get(0);
    }

    public int getCount()
    {
        return songs.size();
    }

    public void show()
    {
        System.out.println(songs);
    }
}

public class PlaylistReview
{
    public static void main(String[] args)
    {
        Playlist mix = new Playlist();
        mix.addSong("Echo");
        mix.addSong("Bloom");
        mix.playNext("Drift");
        System.out.println(mix.skip());
        mix.playNext("Spark");
        mix.show();
        System.out.println(mix.nowPlaying());
        System.out.println(mix.getCount());
    }
}

Echo
[Drift, Spark, Bloom, Echo]
Drift
4

• I can import ArrayList and create an empty list of a chosen element type. Reread
• I can use add and size to build a list and say how many elements it has. Reread
• I can find an element with get, name the valid indexes, and explain an IndexOutOfBoundsException. Reread
• I can replace an element with set and say what set returns. Reread
• I can insert an element at an index and show how later elements shift. Reread
• I can remove an element, use what remove returns, and keep track of shifted indexes. Reread
• I can store numbers in an ArrayList with Integer or Double and explain why the element type matters. Reread
• I can trace code where a list and a variable refer to the same object. Reread