Collections in Java: ArrayList

1. ArrayList class

Today we will explore the ArrayList class. This is the first of several classes known as collections. In Java, collections are such a broad and useful topic that an entire CodeGym quest is devoted to them.

To fully understand how collections are structured and all their nuances, you need to first learn OOP, interfaces, inheritance, the basics of multithreading, and much more.

So today we'll just get acquainted with the simplest kind of collection. But at a deep enough level so that you understand how to use it and how it works. Now then, meet the ArrayList collection.

The backstory

I'll start with a little background. Programmers really didn't like one aspect of arrays: the fact that their size cannot be changed. What if you need to store three more elements in an array, but there is only one empty cell?

The only solution to the space limitations of an array was to create a very large array in order to accommodate all the elements you might need to store. But this was usually a waste of memory. If an array usually contained two or three elements but there was even a tiny chance that it would need to store 100 of them, then it was necessary to create an array with the capacity to store 100.

So what did programmers come up with? They wrote the ArrayList class, which did the same work as the Array class, but was resizable.

ArrayList class

The name of the ArrayList class is formed from two words: Array + List. Array is an array and List is a list.

Each ArrayList object contains an ordinary array of elements. When you read elements from an ArrayList, the object retrieves them from its internal array. When you write elements, it writes them to the internal array.

The ArrayList class lacks all the disadvantages that arrays have. It knows how to:

• Store elements of a specific type
• Dynamically resize the list
• Add elements to the end of the list
• Insert elements at the beginning or middle of the list
• Remove elements from anywhere in the list

For more details, see below:

2. Creating an ArrayList object

To create an ArrayList object, you need to write code like this:

ArrayList<TypeParameter> name = new ArrayList<TypeParameter>();

Where ArrayList is the collection type/class, TypeParameter is the type of the elements stored in the ArrayList collection, and name is the name of an ArrayList<TypeParameter> variable.

The name variable has a generic type. It consists of two types: the type of the collection is indicated first, and then angle brackets are used to indicate the type of the elements stored in the collection.

Examples:

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

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

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

Unlike arrays, collections cannot store primitive types, only reference types. So if you need a collection of ints, use the Integer wrapper class instead.

3. Operations with an ArrayList

Initially, the length of the newly created list is zero, since it contains 0 elements. If you add one element to the list, its length increases by 1. If you remove the added element, the length decreases back to zero.

The following table can teach you more about the methods of the ArrayList class:

void add(Type value)

void add(int index, Type value)

Type get(int index)

void set(int index, Type value)

Type remove(int index)

Type remove(Type value)

void clear()

boolean contains(Type value)

boolean isEmpty()

int size()

Type[] toArray(Type[] array)

These methods let you do almost anything you might want to with the list: swap elements, add elements, and remove elements. You can clear the list with a single command, or even convert the list to an array.

4. Comparison of ArrayList and Array

I don't think we can avoid comparing ArrayList and an array.

There are only 4 actions you can perform with arrays:

• Create an array
• Get an element by index
• Set an element by index
• Get the length of the array

Here are these operations as they apply to an array and an ArrayList:

String[] array = new String[10];

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

String s = array[0];

String s = list.get(0);

array[0] = "Bye";

list.set(0, "Bye");

int count = array.length;

int count = list.size();

Let's compare how an ArrayList works versus how an array works. For example, let's implement this task: "read 10 strings from the keyboard and display them on the screen in reverse order"

Scanner console = new Scanner(System.in);

// Read strings from the keyboard
String[] list = new String[10];

for (int i = 0; i < list.length; i++)
{
    String s = console.nextLine();
    list[i] = s;
}

// Display the contents of the array on the screen
for (int i = 0; i < list.length; i++)
{
    int j = list.length - i - 1;
    System.out.println(list[j]);
}

Scanner console = new Scanner(System.in);

// Read strings from the keyboard
ArrayList<String> list = new ArrayList<String>();

for (int i = 0; i < 10; i++)
{
    String s = console.nextLine();
    list.add(s);
}

// Display the contents of the collection on the screen
for (int i = 0; i < list.size(); i++)
{
    int j = list.size() - i - 1;
    System.out.println(list.get(j));
}

The analogy is clear. Everything is somehow shorter and clearer for arrays. But ArrayList isn't difficult either: to get an element, we use the get() method; to change an element, the set() method; to get the length of the list, the size() method.

So why do programmers use the ArrayList class?

The whole point, of course, is all the other methods that ordinary arrays don't have:

• Add an element to the list
• Add an element to the middle of the list
• Find an element in the list
• Removing an element from a list