The ArrayList Class
Tags: java, programming, learning, beginners
Published: 2024-06-10 12:53:29

An **ArrayList** object can be used to store a list of objects. Now we are ready to introduce a very useful class for storing objects. You can create an array to store objects. But, once the array is created, its size is fixed. Java provides the **ArrayList** class, which can be used to store an unlimited number of objects. Figure below shows some methods in **ArrayList**.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/m5i5tu6dni7cfjozvmx8.png)

**ArrayList** is known as a generic class with a generic type **E**. You can specify a concrete type to replace **E** when creating an **ArrayList**. For example, the following statement creates an **ArrayList** and assigns its reference to variable **cities**. This **ArrayList** object can be used to store strings.

`ArrayList<String> cities = new ArrayList<String>();`

The following statement creates an **ArrayList** and assigns its reference to variable **dates**. This **ArrayList** object can be used to store dates.

`ArrayList<java.util.Date> dates = new ArrayList<java.util.Date> ();`

The statement

`ArrayList<AConcreteType> list = new ArrayList<AConcreteType>();`

can be simplified by

`ArrayList<AConcreteType> list = new ArrayList<>();`

The concrete type is no longer required in the constructor thanks to a feature called _type inference_. The compiler is able to infer the type from the variable declaration.

The program below gives an example of using **ArrayList** to store objects.

```
package demo;
import java.util.ArrayList;

public class TestArrayList {

	public static void main(String[] args) {
		// Create a list to store cities
		ArrayList<String> cityList = new ArrayList<>();
		
		// Add some cities in the list
		cityList.add("London");
		// cityList now contains [London]
		cityList.add("Denver");
		// cityList now contains [London. Denver]
		cityList.add("Paris");
		// cityList now contains [London, Denver, Paris]
		cityList.add("Miami");
		// cityList now contains [London, Denver, Paris, Miami]
		cityList.add("Seoul");
		// cityList now contains [London, Denver, Paris, Miami, Seoul]
		cityList.add("Tokyo");
		// cityList now contains [London, Denver, Paris, Miami, Seoul, Tokyo]
		
		System.out.println("List size? " + cityList.size());
		System.out.println("Is Miami in the list? " + cityList.contains("Miami"));
		System.out.println("The location of Denver in the list? " + cityList.indexOf("Denver"));
		System.out.println("Is the list empty? " + cityList.isEmpty()); // Print false
		
		// Insert a new city at index 2
		cityList.add(2, "Xian");
		// Contains [London, Denver, Xian, Paris, Miami, Seoul, Tokyo]
		
		// Remove a city from the list
		cityList.remove("Miami");
		// Contains [London, Denver, Xian, Paris, Seoul, Tokyo]
		
		// Remove a city at index 1
		cityList.remove(1);
		// Contains [London, Xian, Paris, Seoul, Tokyo]
		
		// Display the contents in the list
		System.out.println(cityList.toString());
		
		// Display the contents in the list in reverse order
		for(int i = cityList.size() - 1; i >= 0; i--)
			System.out.print(cityList.get(i) + " ");
		System.out.println();
		
		// Create a list to store two circles
		ArrayList<CircleFromSimpleGeometricObject> list = new ArrayList<>();
		
		// Add two circles
		list.add(new CircleFromSimpleGeometricObject(2));
		list.add(new CircleFromSimpleGeometricObject(3));
		
		// Display the area of the first circle in the list
		System.out.println("The area of the circle? " + list.get(0).getArea());
	}

}

```

`List size? 6
Is Miami in the list? True
The location of Denver in the list? 1
Is the list empty? false
[London, Xian, Paris, Seoul, Tokyo]
Tokyo Seoul Paris Xian London
The area of the circle? 12.566370614359172`

Since the **ArrayList** is in the **java.util** package, it is imported in line 2. The program creates an **ArrayList** of strings using its no-arg constructor and assigns the reference to **cityList** (line 8). The **add** method (lines 11–21) adds strings to the end of list. So, after
**cityList.add("London")** (line 11), the list contains

`[London]`

After **cityList.add("Denver")** (line 13), the list contains

`[London, Denver]`

After adding **Paris**, **Miami**, **Seoul**, and **Tokyo** (lines 15–21), the list contains

`[London, Denver, Paris, Miami, Seoul, Tokyo]`

Invoking **size()** (line 24) returns the size of the list, which is currently **6**. Invoking **contains("Miami")** (line 25) checks whether the object is in the list. In this case, it returns **true**, since **Miami** is in the list. Invoking **indexOf("Denver")** (line 26) returns the index of **Denver** in the list, which is **1**. If **Denver** were not in the list, it would return **-1**. The **isEmpty()** method (line 27) checks whether the list is empty. It returns **false**, since the list is not empty.

The statement **cityList.add(2, "Xian")** (line 30) inserts an object into the list at the specified index. After this statement, the list becomes

`[London, Denver, Xian, Paris, Miami, Seoul, Tokyo]`

The statement **cityList.remove("Miami")** (line 34) removes the object from the list. After this statement, the list becomes

`[London, Denver, Xian, Paris, Seoul, Tokyo]`

The statement **cityList.remove(1)** (line 38) removes the object at the specified index from the list. After this statement, the list becomes

`[London, Xian, Paris, Seoul, Tokyo]`

The statement in line 42 is same as

`System.out.println(cityList);`

The **toString()** method returns a string representation of the list in the form of **[e0.toString(), e1.toString(), ..., ek.toString()]**, where **e0**, **e1**, . . . , and **ek** are the elements in the list.

The **get(index)** method (line 46) returns the object at the specified index.

**ArrayList** objects can be used like arrays, but there are many differences. Table below lists their similarities and differences.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/1b8pmzx14xgk4hywdpea.png)

Once an array is created, its size is fixed. You can access an array element using the square-bracket notation (e.g., **a[index]**). When an **ArrayList** is created, its size is **0**.

You cannot use the **get(index)** and **set(index, element)** methods if the element is not in the list. It is easy to add, insert, and remove elements in a list, but it is rather complex to add, insert, and remove elements in an array. You have to write code to manipulate the array in order to perform these operations. Note that you can sort an array using the **java.util.Arrays.sort(array)** method. To sort an array list, use the **java.util.Collections.sort(arraylist)** method.

Suppose you want to create an **ArrayList** for storing integers. Can you use the following code to create a list?

`ArrayList<int> list = new ArrayList<>();`

No. This will not work because the elements stored in an **ArrayList** must be of an object type. You cannot use a primitive data type such as **int** to replace a generic type. However, you can create an **ArrayList** for storing **Integer** objects as follows:

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

The program below gives a program that prompts the user to enter a sequence of numbers and displays the distinct numbers in the sequence. Assume that the input ends with **0** and **0** is not counted as a number in the sequence.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/gciiflgsekt7jvqqyhxw.png)

The program creates an **ArrayList** for **Integer** objects (line 8) and repeatedly reads a value in the loop (lines 14–19). For each value, if it is not in the list (line 17), add it to the list (line 18). You can rewrite this program using an array to store the elements rather than using an **ArrayList**. However, it is simpler to implement this program using an **ArrayList** for two reasons.

- First, the size of an **ArrayList** is flexible so you don’t have to specify its size in advance. When creating an array, its size must be specified.
- Second, **ArrayList** contains many useful methods. For example, you can test whether an element is in the list using the **contains** method. If you use an array, you have to write additional code to implement this method.

You can traverse the elements in an array using a foreach loop. The elements in an array list can also be traversed using a foreach loop using the following syntax:

`for (elementType element: arrayList) {
// Process the element
}`

For example, you can replace the code in lines 22-23 using the following code:

`for (int number: list)
 System.out.print(number + “ “);`