Topic 8: ArrayLists

In Topic 6 we covered arrays. We saw that an array was a variable which could be used to hold more than one item. However, there is a problem with the use of arrays. We have to give them a fixed capacity (capacity=number of members the array will hold) which cannot change. For example, this program (there is also an Employee class, but this is not shown) will read in employee records from the keyboard, but the array has a fixed initial size of 10 which cannot be changed:

import java.util.Scanner;

public class FixedArraysApp1
{
    public static void main (String[] args)
    {
        Employee[] employees = new Employee[10];
        String name, jobTitle;
        Scanner scanner = new Scanner(System.in);
        
        for(int count=0; count<10; count++)
        {
            System.out.println("Enter employee name:");
            name = scanner.nextLine();
            System.out.println("Enter employee job title:");
            jobTitle = scanner.nextLine();

            employees[count] = new Employee( name, jobTitle );
        }

        for(int count=0; count<10; count++)
        {
            employees[count].display();
        }
        
    }
}

A slight enhancement of this can be made by specifying a variable for the array capacity when we create it, e.g.:

import java.util.Scanner;

public class FixedArraysApp2
{
    public static void main (String[] args)
    {
        Scanner scanner = new Scanner(System.in);
        
        System.out.println("How many employees");
        String numString = scanner.nextLine();
        int numEmployees = Integer.parseInt(numString);
        
        Employee[] employees = new Employee[numEmployees];
        String name, jobTitle;
        
        
        for(int count=0; count<numEmployees; count++)
        {
            System.out.println("Enter employee name:");
            name = scanner.nextLine();
            System.out.println("Enter employee job title:");
            jobTitle = scanner.nextLine();
        
            Employee e = new Employee( name, jobTitle );
            employees[count] = e;    
        }

        for(int count=0; count<numEmployees; count++)
        {
            employees[count].display();
        }
    }
}

In this example, we are reading in the number of employees from the keyboard and creating the array using this value. This is a bit more flexible than the first example, but still has the problem that once we have specified an initial size for the array, we cannot change it. If the user enters 20, for example, the array's capacity will be 20, and we will not be able to add more than 20 employees. But what if the user then realised that there were more than 20?

Introducing the ArrayList

This is where the ArrayList can come in useful. An ArrayList is a built-in Java class which can vary in capacity. We can create an ArrayList and then keep adding objects to it until the JVM's memory runs out. This makes the ArrayList much more flexible than a plain array. Here is an example of code which uses an ArrayList:

// Product class
public class Product
{
    private String name;
    private double price;
    private int quantityInStock;
    
    public Product (String nameIn, double priceIn, int quantityIn)
    {
        name = nameIn;
        price = priceIn;
        quantityInStock = quantityIn;
    }
    
    public void print()
    {
        System.out.println("Name=" + name + " Price=" + price + " Quantity in stock=" + quantityInStock);
    }
}

// Main class
import java.util.ArrayList;

public class ArrayListExample1
{
    public static void main (String[] args)
    {
        ArrayList<Product> products = new ArrayList<Product> ();
        
        Product product1 = new Product("Smartphone", 299.99, 5);
        Product product2 = new Product("Tablet", 199.99, 3);
        Product product3 = new Product("SD Card", 9.99, 100);
        
        products.add(product1);
        products.add(product2);
        products.add(product3);
        
        for(int count=0; count<products.size(); count++)
        {
            Product currentProduct = products.get(count);
            currentProduct.print();
        }
    }
}

As an aside, note how I no longer include this when referring to the attributes of Product. I have included this so far for clarity, to help distinguish between attributes and parameters, but most real Java programs would not include it. Now you are (hopefully) used to using attributes, I have now removed it.
Note how we must import the ArrayList from java.util before we use it:
```
import java.util.ArrayList;
```
The first line in the main() creates the ArrayList:
```
ArrayList<Product> products = new ArrayList<Product> ();
```
Note that ArrayLists are objects, so we use new to create them, just like any other object. Note that the data type includes what type of data the ArrayList is holding, so here the data type is ArrayList<Product> because it is an ArrayList holding Product objects.
We then create three Product objects.
We then add the three Product objects to the ArrayList with the add() method of ArrayList.
We then loop through the ArrayList. The size() method of ArrayList gives us the number of elements in (members of) the ArrayList.
Inside the loop, we obtain the current Product using the get() method of ArrayList. The get() method is how we index an ArrayList:
```
Product currentProduct = products.get(count);
```
This line is creating a variable called currentProduct and setting it equal to the current member of the ArrayList.
Finally, we print this Product.

A more efficient version of the above code

The code above was written in a way to try and make it as clear as possible what is going on. However, we could write the code more efficiently (less lines of code) as follows:

import java.util.ArrayList;

public class ArrayListExample1
{
    public static void main (String[] args)
    {
        ArrayList<Product> products = new ArrayList<Product> ();
        
        products.add(new Product("Smartphone", 299.99, 5));
        products.add(new Product("Tablet", 199.99, 3));
        products.add(new Product("SD Card", 9.99, 100));
        
        for(int count=0; count<products.size(); count++)
        {
            products.get(count).print();
        }
    }
}

Note how, rather than creating three variables product1, product2 and product3, we create the product objects and add them to the array list in one statement. This is perfectly acceptable as the add() method of the ArrayList is expecting a Product object as a parameter - and we are giving it one.

Note also how we combine two statements into one in the for loop. Rather than storing the current member of the ArrayList in a variable called currentProduct and then calling the print() method on currentProduct, we call the print() method directly on the return value of products.get(count). Since products.get(count) gives us a Product object, this is, again, acceptable.

Exercises

Create an Employee class with attributes for name and job title, a constructor which initialises the name and job title, and a display() method which displays the employee's details.
Write a program which adds three employees to an ArrayList and loops through and displays them.
Rewrite the second Employee example above (FixedArraysApp2) so that it uses an ArrayList rather than a regular array.
After reading in the employees from the keyboard, modify the second loop to display them all, so that it uses ArrayLists.
Modify your code so that, rather than the user entering the number of employees, the program keeps adding employees until the user enters "quit" for the employee name.
Return to your chase game. Store the three monsters in an ArrayList rather than a regular array.