The ArrayList Data Structure

Standard Arrays at High Speed!

More Safety, More Efficient, and Less Overhead!

The Java ArrayList ClassJava provides an ArrayList class to make it easier to

work with arrays. An ArrayList is a one-dimensional array.

There is a lot of overhead code to set up a standard array, fill it, track its logical size, and manipulate values in the array. An ArrayList make these operations easier.

However, an ArrayList holds only objects, not primitive values like int, double, char or boolean. But in particular Java has the Integer and Double classes so you can place numbers in an ArrayList.

Instantiating an ArrayListWhen you declare a standard array, you have to tell

Java a fixed number of memory locations that you want the array to contain. During the run of a program, this cannot be changed unless you create a new standard array and copy all of the elements to it. This would be awkward to do and implement in every program that uses standard arrays.

When you declare an ArrayList, you don’t have to tell Java how much storage space you need. The ArrayList will be created for a beginning amount and then it will automatically resize itself when it becomes full and more elements need to be added.

Instantiating an ArrayListDeclaring and instantiating a standard array:

double [ ] nums = new double [20];

Declaring and instantiating an ArrayList:

ArrayList <Double> nums = new ArrayList <Double> ( );

No square bracket [ ] notation is used for an ArrayList.

Note the use of the templating angle brackets < and > that enclose the type of object to be placed in the array.

Instantiating an ArrayListDeclaring and instantiating an ArrayList of other types:

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

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

ArrayList <Student> students = new ArrayList <Student> ( );

ArrayList <Shape> shapes = new ArrayList <Shape> ( );

The ArrayList API says that all of the above ArrayLists will be constructed with an initial capacity of ten.

Note the empty ( ) parentheses at the end of the constructor call. Don’t forget to include these.

Instantiating an ArrayListYou can declare and instantiate an ArrayList with an initial

capacity of a certain size if you know approximately how many elements you will place in the ArrayList.

The only real reason to do this is to keep the ArrayList from automatically resizing itself over and over again until all of the elements have been added to the ArrayList. However, this is not particularly inefficient for today’s computers unless you need to store many elements.

For example, if you know you will have 1000 random integers in an ArrayList, you could use:

ArrayList <Integer> nums = new ArrayList <Integer> (1000);

Raw or Generic ArrayList?When you instantiate an ArrayList as you have just seen, we call

it a generic ArrayList, because the programmer must specify the element type for the list as in …

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

Making a generic ArrayList with templating became available beginning with Java 1.5 and higher.

Prior to that, programmers could only make a raw ArrayList, where you could put all kinds of objects in the same ArrayList, but care had to be taken to make sure only one kind of object was placed in a list. You can still declare and instantiate a raw ArrayList, like the following, but most compilers will “complain” and at least give you a warning if you are using Java 1.5 or higher. (some people refer to Java 1.5 as Java 5)

ArrayList names = new ArrayList ( );

Advantages of ArrayListOperations are much much easier and less complex

for:

• traversing an ArrayList (accessing each element to

print or perform an operation on it)

• insertions anywhere in the ArrayList

• removals anywhere in the ArrayList

• searching an ArrayList

An ArrayList tracks its own logical size and grows or shrinks automatically depending on the number of elements it has.

ArrayList Differences • Instead of using [] to manipulate elements, methods are

called to perform operations.

• An ArrayList tracks its logical size and physical size. We don’t necessarily know what the physical size is and we don’t need to, because if more memory locations are needed then it will automatically resize itself. It is helpful to be able to access the logical size of an ArrayList when performing certain operations. The size() method is used to get the number of elements in the list. The logical size is 0 when an ArrayList is constructed and its logical size is automatically adjusted when an element is added or deleted.

• An ArrayList does have indices and the positions of the elements range from index 0 to index logical size - 1.

java.util.ArrayListThe ArrayList class is part of the java.util package. So it is necessary to import this class by including:

import java.util.ArrayList;

The ArrayList class implements the List interface.

That means that the ArrayList class must have all of the

methods that are defined in the List interface. You will learn

more about interfaces very soon, but we want to make you

familiar with this fact now. The formal way to state this fact for

the ArrayList class is:

class java.util.ArrayList<E> implements java.util.List<E>

The E in <E> simply stands for any kind of object or class name.

Declaring Variables of type ListDeclaring and instantiating an ArrayList where the variable is

of type List interface is the preferred way to go for many programmers. As you gain more experience programming you will understand why. Don’t worry about that for now.

Here is the alternate way to declare and instantiate the ArrayList named students using the List interface:

List <Student> students = new ArrayList < Student > ( );

Compare this to the previous way:

ArrayList <Student> students = new ArrayList < Student > ( );

The java.util.List<E> interfaceAn interface tells you the method signatures of the methods

that classes that implement the interface must have. Here is what part of Java’s List interface looks like:

public interface List {

public int size ( );public boolean add (E obj);public void add (int index, E obj);public E get (int index);public E set (int index, E obj);public E remove (int index);…….

}

ArrayList and LinkedList use the List InterfaceA second class named the LinkedList class also implements the List interface.

Since both of these classes have the same methods (but different code for them), we could choose to use the following declaration:

List < Student > students = new LinkedList < Student > ( );

instead of …

List <Student> students = new ArrayList < Student > ( );

This is one of the advantages of declaring variables of type List, because we don’t need to change any of the code in the program … only where students is declared and instantiated if we want to have a different kind of list.

Some of the code in the LinkedList class is more efficient that the ArrayList class, because the LinkedList class is not based on a standard array but a different kind of list. You will learn about that if you take Advanced Computer Programming.

Declaring Variables of type List

Also, if we declare the variable shapes to be of type List <Shape>, then if the Shape is the parent of several classes like Circle, Rectangle, and Triangle, then we can hold all of those kinds of objects in the same list. This can be a real advantage. Now you are starting to learn about inheritance!

List <Shape> shapes = new ArrayList <Shape> ( );

The ArrayList Subset of Methods

There are many methods in the ArrayList class if you look up its API on line.

However, we only want to work with a few methods of the ArrayList class … those in particular that you are expected to know for the AP Exam.

You might not receive full credit on a free response coding question if you try to use methods other than the ones specified by the College Board.

The specified methods and what they do are listed on the next slide.

The ArrayList Subset of MethodsArrayList method What the Operation Does

int size ( ) returns the logical size of the list

boolean add (E obj) appends the object obj to the end of the list and returns true if successful (the fact that it returns true may be helpful sometimes)

void add (int index, E obj) inserts the object obj at position index where index fulfills the expression 0 ≤ index ≤ size. If index is out of bounds in the range of index < 0 || index > size(), then Java throws an IndexOutOfBoundsException. Once obj is inserted, then the elements at position index and higher are moved to the right so that 1 is added to their indices and then the logical size is adjusted. Note: if there are 3 elements in the list at indices 0, 1, and 2, then obj can be added at index 3 without an out of bounds error

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 and returns the element formerly at the specified position

E remove (int index) removes the element from position index in the list and then moves all elements at position index + 1 and higher to the left … subtracting 1 from their indices and then adjusting the logical size. The element formerly at the specified position is returned

Wrapper ClassesThe Integer and Double classes are called wrapper classes, because they are used to “wrap up” primitive int and double values as objects so they can be put in an ArrayList or other kind of data structure.

We used the Integer and Double classes earlier this year when we used …

Integer.parseInt() and Double.parseDouble()

to get the values from JTextFields or InputDialog boxes.

Now let’s look a little closer at the Integer and Double classes see how to wrap up an int or double as an object.

Wrapping & Unwrapping intsYou don’t need to know the parseInt() method for the AP Exam, but you do need to know how to use the following methods of the Integer class:

The constructor that has one parameter that is an int.

If you want to wrap up an int, like 345, as an Integer object, then you would use the constructor to wrap it up:

Integer intObj = new Integer(345);

You have now wrapped up the int 345 and made it an Integer object and the variable intObj refers to that object!

To unwrap the Integer object intObj and get the int value 345 out of it and store it in the int variable x, then you have to call the intValue() method …

int x = intObj.intValue();

Wrapping & Adding IntegersFor the ArrayList …

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

if we want to place the values 5, 10, and 15 in nums, in that order, we would wrap them up and add them as follows:

Integer intObj1 = new Integer(5);

nums.add(intObj1); // adds to the end of the list

Integer intObj2 = new Integer(10);

nums.add(intObj2); // adds to the end of the list

You can also combine the lines by using …

nums.add(new Integer(15)); // adds to the end of the list

Autoboxing IntegersPrior to Java 1.5, with a raw ArrayList, you had to wrap up int values. However, with the advent of Java 1.5 autoboxing became available. Here is the same code with autoboxing:

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

nums.add(5); // autoboxing 5 and adding it

nums.add(10); // autoboxing 10 and adding it

nums.add(15); // autoboxing 15 and adding it

However, the College Board still wants you to know how to wrap up int values.

Unboxing IntegersPrior to Java 1.5 with a raw ArrayList, you had to unwrap int values before using them. However, with the advent of Java 1.5 unboxing became available. Here is the code with unboxing:

int x = nums.get(0); // get Integer at index 0 & unwrap using unboxing

int y = nums.get(1); // get Integer at index 1 & unwrap using unboxing

int z = nums.get(2); // get Integer at index 2 & unwrap using unboxing

Here intValue() is called automatically by Java to unwrap the Integer object returned by get(i) so it can be stored in x, y, or z.

You don’t have to call intValue() to unwrap because of unboxing!

However, the College Board still wants you to know how to unwrap Integer objects.

Wrapping & Unwrapping doublesYou don’t need to know the parseDouble() method for the AP Exam, but you do need to know how to use the following methods of the Double class:

The constructor that has one parameter that is a double.

If you want to wrap up a double, like 12.3, as a Double object, then you would use the constructor to wrap it up:

Double floatObj = new Double(12.3);

You have now wrapped up the double 12.3 and made it a Double object and the variable floatObj refers to that object!

To unwrap the Double object floatObj and get the double value 12.3 out of it and store it in the double variable d, then you have to call the doubleValue() method …

double d = floatObj.doubleValue();

Wrapping & Adding DoublesFor the ArrayList …

ArrayList <Double> floats = new ArrayList <Double> ( );

if we want to place the values 5.5, 6.6, and 7.7 in floats, in that order, we would wrap them up and add them as follows:

Double floatObj1 = new Double (5.5);

floats.add(floatObj1); // adds to the end of the list

Double floatObj2 = new Double (6.6);

floats.add(floatObj2 ); // adds to the end of the list

You can also combine the lines by using …

floats.add(new Double (7.7)); // adds to the end of the list

Autoboxing DoublesPrior to Java 1.5, with a raw ArrayList, you had to wrap up double values. However, with the advent of Java 1.5 autoboxing became available. Here is the same code with autoboxing:

ArrayList <Double> floats = new ArrayList < Double > ( );

floats.add(5.5); // autoboxing 5.5 and adding it

floats.add(6.6); // autoboxing 6.6 and adding it

floats.add(7.7); // autoboxing 7.7 and adding it

However, the College Board still wants you to know how to wrap up double values.

Unboxing DoublesPrior to Java 1.5 with a raw ArrayList, you had to unwrap double values before using them. However, with the advent of Java 1.5 unboxing became available. Here is the code with unboxing:

double b = floats.get(0); // get Double at index 0 & unwrap using unboxing

double c = floats.get(1); // get Double at index 1 & unwrap using unboxing

double d = floats.get(2); // get Double at index 2 & unwrap using unboxing

Here doubleValue() is called automatically by Java to unwrap the Double object returned by get(i) so it can be stored in b, c, or d.

You don’t have to call doubleValue() to unwrap because of unboxing!

However, the College Board still wants you to know how to unwrap Integer objects.

Adding Elements to an ArrayList - add(obj)

The following code stores the first 100 multiples of 3 in nums in order:

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

int value = 3;

for (int i = 0; i < 100; i++)

{

nums.add(value); // adds at the end of the list

value += 3;

}

Note: if nums was a standard array, we would use …

nums [i] = value; in place of nums.add(value);

Getting Elements from an ArrayList - get(i)

The following code prints the values stored in nums with 10 values per line with a field width of 5:

for (int i = 0; i < nums.size(); i++)

{

if ( (i + 1) % 10 == 0 )

System.out.printf( “%5d%n”, nums.get(i) );

else

System.out.printf( “%5d”, nums.get(i) );

}

Note: if nums was a standard array, we would use …

System.out.printf( “%5d”, nums[i] );

Getting Elements from an ArrayList - get(i)

To obtain the first element in an ArrayList always use …

nums.get(0);

To obtain the last element in an ArrayList always use …

nums.get(nums.size() - 1);

Note that since there are num.size() elements in the ArrayList, then the index of the first element is 0 and the index of the last element is nums.size() - 1.

Removing Elements from a Position - remove(i)

The following code removes and prints all of the multiples of 6 from nums in a field width of 5:

int i = 0;

while ( i < nums.size() ) {

if ( nums.get(i) % 6 == 0 ) {

int x = nums.remove(i) ;

System.out.printf( “%5d”, x );

// don’t increment i because elements are shifted down

} else // if not evenly divisible by 6 increment i

i++;

}

Removing Elements from a Position - remove(i)

The following code removes and prints all of the multiples of 6 from nums in a field width of 5 using a for loop:

for (int i = 0; i < nums.size() ; i++)

{

if ( nums.get(i) % 6 == 0 ) {

int x = nums.remove(i) ;

System.out.printf( “%5d”, x );

i--; // to cancel the effect of i++ in loop header

}

}

Removing Elements from a Position - remove(i)

To delete the first element in an ArrayList always use …

nums.remove(0);

To delete the last element in an ArrayList always use …

nums. remove(nums.size() - 1);

Again, since there are num.size() elements in the ArrayList, then the index of the first element is 0 and the index of the last element is nums.size() - 1.

Adding Elements at a Position - add(i, obj)

The following code adds the integer 3 at the first of the list named nums using the add(i, obj) method, where the list initially contains 6, 9, 12.

nums.add (0, 3); // add 3 at index 0.

The list now contains: 3 6 9 12

The following code adds the integer 15 at the end of the list no matter how many elements there are using the add(i, obj) method.

nums.add (nums.size() , 15); // add 15 after the last element

Since nums.size() is 4 before adding 15, then 15 is added at index 4. Obviously 3, 6, 9, &12 are in indices 0, 1, 2, & 3.

The list now contains: 3 6 9 12 15

Replacing Elements at a Position - set(i, obj)

Assume nums contains: 3 6 9 12 15

The following code replaces the element at index 2 with the value 10 using the set(i, obj) method. It returns the replaced element and prints it out.

int x = nums.set (2, 10); // replace 9 at index 2 with 10.

System.out.println(“The replaced value was ” + x);

The list now contains: 3 6 10 12 15

Replacing the last value in the ArrayList …

int x = nums.set (nums.size() - 1, 20);

The list now contains: 3 6 10 12 20