Java ArrayList - Working with ArrayList

An ArrayList in Java represent a resizable list of objects. We can add, remove, find, sort and replace elements in this list. ArrayList is part of Java’s collection framework and implements Java’s List interface.

ArrayList class extends AbstractList class which implements List interface. The List interface extends Collection and Iterable interfaces in hierarchical order.

1. ArrayList Features

ArrayList has following features –

Ordered – Elements in arraylist preserve their ordering which is by default the order in which they were added to the list.
Index based – Elements can be randomly accessed using index positions. Index start with '0'.
Dynamic resizing – ArrayList grows dynamically when more elements needs to be added than it’s current size.
Non synchronized – ArrayList is not synchronized, by default. Programmer needs to use synchronized keyword appropiately or simply use Vector class.
Duplicates allowed – We can add duplicate elements in arraylist. It is not possible in sets.

2. How ArrayList Works?

ArrayList class is implemented arounda backing array. The elements added or removed from arraylist are actually modified in this backing array. All ArrayList methods access this array and get/set elements in the array.

ArrayList basically cab be seen as resizable-array implementation in Java.

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, 
        		   Cloneable, java.io.Serializable
{
	transient Object[] elementData;		//backing array
	private int size;					//array or list size

	//more code
}

3. Java Array Vs ArrayList

An array is fixed size data structure where the size has to be declared during initialization. Once the size of an array is declared, it’s not possible to resize it without creating a new array.

Integer[] numArray = new Integer[5];

The ArrayList class offers to remove this limitation. An ArrayList can be created with any initial size (default 16), and when we add more items to it, it’s size grows dynamically without any intervention by the programmer.

Many people call arraylist as dynamic arrays.

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

4. Creating an ArrayList

4.1. Constructors

To create ArrayList, we can call one of it’s constructors.

Constructor	Description
ArrayList()	It is default constructor. It creates an empty arraylist with initial capacity 16.
ArrayList(int capacity)	It creates an empty arraylist with the given initial `capacity`.
ArrayList(Collection<? extends E> c)	It creates an arraylist that is initialized with the elements of the collection `c`.

4.2. Non-generic Vs Generic

A generic arraylist clearly mentions the type of objects, it will store. It helps in avoiding a lot of defects caused by incorrect typecasting.

//Non-generic arraylist - NOT RECOMMENDED !!
ArrayList list = new ArrayList();

//Generic Arraylist with default capacity
List<Integer> numbers = new ArrayList<>(); 

//Generic Arraylist with the given capacity
List<Integer> numbers = new ArrayList<>(6); 

//Generic Arraylist initialized with another collection
List<Integer> numbers = new ArrayList<>( Arrays.asList(1,2,3,4,5) );

4.3. List of primitive types

In array list, we are supposed to add only objects. But in case, we are required to add primitive data types such as int, float etc, we can use their wrapper classes for providing type information during arraylist initialization.

When we add the int or float value to array list, values are automatically upcasted.

In given example, we have created an array list of Integer values. When we add int value 1, it is automatically converted to new Integer(1).

List<Integer> numbers = new ArrayList<>(6); 

numbers.add(1); // This runs fine

4.4. Create and initialize list in one line

Generally, creating an arraylist in multi-step process. In first step, we create empty array list. In later steps, we populate the list with elements – one by one.

Using Arrays.asList() and constructor ArrayList(collection), we can combine these steps in single statement.

ArrayList<String> charList = new ArrayList<>(Arrays.asList(("A", "B", "C"));

5. Adding, updating and removing elements

Use following listed methods based on the application requirements.

Method	Description
`add(element)`	Appends the specified element to the end of this list.
`add(index, element)`	Inserts the specified element at the specified index position.
`addAll(collection)`	Appends all of the elements in the specified collection to the end of the list.
`addAll(index, collection)`	Appends all of the elements in the specified collection at the specified index position.
`set(index, newElement)`	Replaces the element at the specified `index` position with the specified `newElement`.
`remove(index)`	Removes the element at the specified `index` position.
`remove(element)`	Removes the first occurrence of the specified `element`. If no such element is find in the list, the list remains unchanged.
`removeRange(startIndex, endIndex)`	Removes all of the elements whose index is between `startIndex` (inclusive) and `endIndex` (exclusive).
`removeAll(collection)`	Removes all the elements that are contained in the specified `collection`.
`clear()`	Removes all of the elements and make the list empty.

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

names.add("lokesh");    //[lokesh]
names.add("alex");      //[lokesh, alex]

names.set(1, "brian");  //[lokesh, brian]

names.remove(1);        //[lokesh]

6. Access elements from ArrayList

To get an element from array list, we have two methods.

6.1. get(index)

If we know the index location in advance, then we can call the get(index) which returns the element present at index location.

Please remember that indexes start with zero.

ArrayList<String> alphabetsList = new ArrayList<>(Arrays.asList(("A", "B", "C"));

String aChar = alphabetsList.get(0);	// A

6.2. iterator.next()

Use iterator() or listIterator() to get the reference of Iterator instance. This iterator can be used to iterate the elements in the arraylist.

The next() method returns the element at current index location and increment the index count by one. Call hasNext() method to check if there are more elements in the list to iterate.

ArrayList<Integer> digits = new ArrayList<>(Arrays.asList(1,2,3,4,5,6));

Iterator<Integer> iterator = digits.iterator();

while(iterator.hasNext()) 
{
	System.out.println(iterator.next());
}

Program output.

7. Iterating over an ArrayList

7.1. Iterator

ArrayList<Integer> digits = new ArrayList<>(Arrays.asList(1,2,3,4,5,6));

Iterator<Integer> iterator = digits.iterator();

while(iterator.hasNext()) 
{
	System.out.println(iterator.next());
}

7.2. For loop

Using for loop, we need to get the current element using the current index counter.

ArrayList<Integer> digits = new ArrayList<>(Arrays.asList(1,2,3,4,5,6));

for(int i = 0; i < digits.size(); i++) 
{
    System.out.print(digits.get(i));
}

7.3. forEach loop

forEach loop workds pretty much same to simple for loop.Only difference is that the JVM manages the counter initialization and increment. We get the next element in each iteration in the loop.

ArrayList<Integer> digits = new ArrayList<>(Arrays.asList(1,2,3,4,5,6));

for(Integer d : digits) 
{
    System.out.print(d);
}

8. Length of the ArrayList

To get the length of the array list, we use the size() method. For example,

ArrayList<Integer> digits = new ArrayList<>(Arrays.asList(1,2,3,4,5,6));

System.out.print( digits.size() );		// 6

9. Sorting an ArrayList

ArrayList sort() method sorts the list according to the order induced by the specified Comparator instance. All elements in the list must must be mutually Comparable.

public class AgeSorter implements Comparator<Employee> 
{
    @Override
    public int compare(Employee e1, Employee e2) {
        //comparison logic
    }
}

ArrayList<Employee> employees = new ArrayList<>();

employees.add(new Employee(...));
employees.add(new Employee(...));
employees.add(new Employee(...));

employees.sort(new NameSorter());

10. ArrayList Methods

11. Java ArrayList Examples

References:

ArrayList Java Docs

Was this article helpful?

Twitter Facebook LinkedIn Reddit Pocket

Java – ArrayList