4.8 ArrayList Methods

1. Creating an ArrayList

An ArrayList object is mutable in size (it can grow and shrink) and it contains object references 4.8.A.1. The class is part of the java.util package, so an import statement must make it available 4.8.A.4. The constructor ArrayList() constructs an empty list 4.8.A.2.

Java allows the generic type ArrayList<E>, where the type parameter E is the type of the elements 4.8.A.3. With ArrayList<E>, the parameters and return types of the ArrayList methods are type E. Using ArrayList<E> is preferred over plain ArrayList, because it lets the compiler find errors that would otherwise only be found at run time 4.8.A.3.

import java.util.ArrayList;

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

Output:

0
[]

Printing an ArrayList shows its elements in square brackets, separated by commas.

With a type parameter, a wrong type is caught by the compiler:

ArrayList<String> songs = new ArrayList<String>();
songs.add(42);

Compiler error:

error: incompatible types: int cannot be converted to String

Background: without a type parameter, the same kind of mistake compiles and only fails when the program runs. This is why ArrayList<E> is preferred.

ArrayList songs = new ArrayList();
songs.add(42);
String first = (String) songs.get(0);
System.out.println(first);

Output:

Exception in thread "main" java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')

Because the elements are object references, a list of numbers uses a wrapper class: ArrayList<Integer> or ArrayList<Double>. Autoboxing and unboxing (topic 4.7) convert for you.

2. size, add and get

These methods are in the Java Quick Reference 4.8.A.5:

• 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 get(int index) returns the element at position index.

ArrayList<Integer> laps = new ArrayList<Integer>();
laps.add(62);                          // autoboxing: int 62 becomes an Integer
laps.add(58);
boolean ok = laps.add(60);

System.out.println(ok);
System.out.println(laps.size());
System.out.println(laps.get(1));
int best = laps.get(1);                // unboxing
System.out.println(best + 1);
System.out.println(laps);

Output:

true
3
58
59
[62, 58, 60]

index	0	1	2
laps	62	58	60

3. add at an index: shifting right

void add(int index, E obj) inserts obj at position index, where 0 <= index <= size. The elements at position index and higher move to the right (1 is added to their indices), and 1 is added to the size 4.8.A.5.

ArrayList<String> queue = new ArrayList<String>();
queue.add("Ana");
queue.add("Ben");
queue.add("Cleo");

queue.add(1, "Dev");          // insert at index 1
System.out.println(queue);

queue.add(4, "Eli");          // index == size: same as appending
System.out.println(queue);
System.out.println(queue.size());

Output:

[Ana, Dev, Ben, Cleo]
[Ana, Dev, Ben, Cleo, Eli]
5

index	0	1	2	3	4
before	“Ana”	“Ben”	“Cleo”
after add(1, "Dev")	“Ana”	“Dev”	“Ben”	“Cleo”
after add(4, "Eli")	“Ana”	“Dev”	“Ben”	“Cleo”	“Eli”

“Ben” was at index 1 and is now at index 2: inserting changed its index.

4. set and remove

• E set(int index, E obj) replaces the element at position index with obj and returns the element formerly at that position 4.8.A.5. The size does not change.
• E remove(int index) removes the element at position index, moves the elements at index + 1 and higher to the left (1 is subtracted from their indices), subtracts 1 from the size, and returns the element formerly at that position 4.8.A.5.

ArrayList<String> queue = new ArrayList<String>();
queue.add("Ana");
queue.add("Dev");
queue.add("Ben");
queue.add("Cleo");

String old = queue.set(2, "Bea");
System.out.println(old + " was replaced: " + queue);

String gone = queue.remove(0);
System.out.println(gone + " left: " + queue);
System.out.println("Now first: " + queue.get(0) + ", size " + queue.size());

Output:

Ben was replaced: [Ana, Dev, Bea, Cleo]
Ana left: [Dev, Bea, Cleo]
Now first: Dev, size 3

index	0	1	2	3
before	“Ana”	“Dev”	“Ben”	“Cleo”
after set(2, "Bea")	“Ana”	“Dev”	“Bea”	“Cleo”
after remove(0)	“Dev”	“Bea”	“Cleo”

Watch out: with an ArrayList<Integer>, remove(1) uses the Quick Reference method remove(int index): it removes the element at index 1, not the value 1.

ArrayList<Integer> nums = new ArrayList<Integer>();
nums.add(1);
nums.add(5);
nums.add(9);
nums.remove(1);
System.out.println(nums);

Output:

[1, 9]

5. Valid indexes and IndexOutOfBoundsException

The indices of an ArrayList start at 0 and end at the number of elements minus 1 4.8.A.6, so get, set and remove accept 0 to size() - 1. (Only add(index, obj) also accepts size().) Any other index throws an IndexOutOfBoundsException when the code runs.

ArrayList<Double> times = new ArrayList<Double>();
times.add(9.8);
times.add(10.1);
times.add(9.9);

System.out.println(times.get(times.size() - 1));
System.out.println(times.get(times.size()));

Output:

9.9
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index 3 out of bounds for length 3

set cannot grow a list either. On an empty list, set(0, ...) fails because index 0 does not exist yet; use add.

6. Array or ArrayList?

Task	Array (int[] a)	ArrayList<Integer> list
Create	new int[5] or {3, 1, 4}	new ArrayList<Integer>() (starts empty)
Number of elements	a.length	list.size()
Read element i	a[i]	list.get(i)
Change element i	a[i] = 7;	list.set(i, 7);
Add at the end	not possible (fixed length)	list.add(7);
Insert or remove in the middle	write your own shift	list.add(i, 7); and list.remove(i);
Element types	primitives or references	references only
Bad index	ArrayIndexOutOfBoundsException	IndexOutOfBoundsException