8.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
8.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<>();
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.
8.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.
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?
When adding Integer
objects to an ArrayList<Integer>
, the simplest thing
to do is add an int
and let autoboxing take care of wrapping it in an
Integer
for you: add(5)
. If you really want to, you can wrap the int
yourself; the best way is with the static method Integer.valueOf
:
add(Integer.valueOf(5))
. Another option, and the least good, is to use the
deprecated Integer
constructor: add(new Integer(5))
. Note, however, that
you may see code like the last version on the AP exam as that constructor was
not deprecated until Java 9 and the exam uses Java 7.
ArrayList<Integer> list = new ArrayList<>();
list.add(new Integer(5)); // Deprecated, but something you may see on the exam
list.add(5); // How you should write it.
list.add(Integer.valueOf(5)); // This is also okay.
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 Student
s.
An example of an ArrayList
of Student
objects. Add a new student with
your name and info in it.
8.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.
What will the code below print out? Try figuring it out before running it.
Remember that ArrayList
s start at index 0 and that the add(index,obj) always
has the index as the first argument.
Note
ArrayList
s like arrays start numbering their elements from 0.
- [1, 2, 3, 4, 5]
- This would be true if all the
add
method calls wereadd(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.
7-2-4: What will print when the following code executes?
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(1);
list1.add(2);
list1.add(3);
list1.add(2, 4);
list1.add(5);
System.out.println(list1);
You can step through the code above by clicking on this Java Visualizer.
- ["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")
7-2-5: What will print when the following code executes?
ArrayList<String> list1 = new ArrayList<>();
list1.add("Anaya");
list1.add("Layla");
list1.add("Sharrie");
list1.add(1, "Sarah");
System.out.println(list1);
You can step through the code above by clicking on the following Java Visualizer.
8.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.
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.
- [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)
7-2-7: What will print when the following code executes?
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(1);
list1.add(2);
list1.add(3);
list1.remove(2);
System.out.println(list1);
You can step through the code above by clicking on the following RemoveExample.
8.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 ArrayList
s 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.
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?
- [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 lastadd
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.
7-2-9: What will print when the following code executes?
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(1);
list1.add(2);
list1.add(3);
list1.set(2, 4);
list1.add(2, 5);
list1.add(6);
System.out.println(list1);
You can step through the code above by clicking on the following Example1.
- ["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"]
7-2-10: What will print when the following code executes?
ArrayList<String> list1 = new ArrayList<>();
list1.add("Anaya");
list1.add("Layla");
list1.add("Sharrie");
list1.set(1, "Destini");
list1.add(1, "Sarah");
System.out.println(list1);
You can step through the code above by clicking on the following Example2.
8.2.6. Comparing arrays and ArrayList
s¶
When do you use arrays and when do you use ArrayList
s? 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 ArrayList
s:
// 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<>();
ArrayList<String> nameList = new ArrayList<>();
Here is a comparison of how to access and change elements in arrays and
ArrayList
s. Note that ArrayList
s have a method size()
instead of a
length
property, and ArrayList
s 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), ArrayList
s,
and String
s made by AP CSA teacher Sam Procopio of Bishop Blanchet High
School.
8.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.
8.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