Home » Java Tutorial » ArrayList Java

ArrayList Java


Reading Time - 19 mins

ArrayList in Java is the most commonly used data structure for creating a dynamic size array. It extends the Abstract class and implements the Java List interface. The main difference between array and ArrayList is that the array is static(we cannot add or remove elements) while ArrayList is dynamic(we can add, remove or modify elements)

Java ArrayList Hierarchy

Arraylist in java

ArrayList Declaration

In order to use ArrayList in Java, we must import java.util.ArrayList.  Below is the declaration of an ArrayList

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable,Serializable

where E denotes the element or Object type (Eg: Integer, String, etc)

ArrayList Constructors

We can create ArrayList in Java Constructors in below 3 methods:

ConstructorDescription
ArrayList()This creates an empty array list
ArrayList(Collection c)This creates an array list with the elements of collection
ArrayList(int size)This creates an array list of specific size

Java ArrayList Features

  • It is a resizeable dynamic array where we can add, modify or remove elements any time from the list
  • Maintains a sequential order.
  • It is easy to access any data from the list based on the index.
  • Allows duplicate elements in the list

Java ArrayList Methods

In addition to the below methods, ArrayList in Java has access to all methods of List interface.

MethodDescriptionParameter
Boolean add(Object e)Adds the specified element to the end of list.e - the element to be added.
Return value - True
void add(int index, Object e)Adds the element to the specified index. If the index already contains an element, it is shifted to the rightindex- the index at which the element needs to be inserted
e - the element which needs to be inserted
Boolean addAll(Collection c)Adds a collection of specified elements to the list.c - collection of elements to be added
Return value - true
Boolean addAll(int index, Collection c)Adds a collection of elements at the specified index. If the index already contains element, it is subsequently shifted to the rightindex - index at which the elements needs to be added
c - collection of elements to be added
Return value - True
void clear()Clears all the elements in the list.
Boolean contains(Object o)Checks if the list contains the specified elementReturn value - true if the list contains the element
Boolean containsAll(Collection c)Checks if the list contains all the elements in the collectionReturn value - true if the list contains all the elements
Boolean equals(Object o)Compares if the list contains all the specified elements in the exact orderReturn value - true if object elements match with the list
Object getIndex(int index)Retrieves the element at the specified indexindex - the index at which the element that needs to be retrieved
Return value - The element at the specified index
int indexOf(Object o)Fetches the index of the first occurrence of the specified elemento - The element to be identified
Return value - index value
Boolean isEmpty()Checks if the list is empty or notReturn value - true if list contains no values
Iterator iterator()Retrieves the iterator of list in sequenceReturn value - Iterator
int lastIndexOf(Object o)Retrieves the last occurrence of the specified objecto - Element to be identified
Return value - index value
Object remove(int index)Removes the element at the specified indexindex - index position at which the element has to be removed
Return value - The element that is removed
Boolean remove(Object o)Removes the first occurrence of the specified object from the list if presento - The element that needs to be removed
Return value - true if list contains the element
Boolean removeAll(Collection c)Removes the first occurrence of all the elements in the collection from the list if presentc - collection of elements
Return value - true if the list contains the collection
Boolean retainAll(Collection c)Retains all the elements specified in collection in list. Other elements will be removedc - collection of elements that has to be retained
Return value - true if the list changed due to the method called
Object set(int index, Object o)Replaces the element at the specified index with the object passedo - the element to be replaced
index - index of the element
Return value - Returns the element which was previously at the specified index
int size()Fetches the size of the listReturn value - size of the list
List sublist(int fromIndex, int toIndex)Retrieves the part of the list based on start and endIndexfromIndex - position from which the sublist has to be retrieved (included)
toIndex - the index until which the sublist has to be retrieved (excluded)
void ensureCapacity(int mincapacity)Increases the size of arraylist and ensures it can hold minimum capacity as mentionedmincapacity - minimum number of elements the arraylist can hold
void sort(Comparator c)Sorts the elements in the list based on the comparator argumentc - compartor which is used to compare the list elements
Object[] toArray()Returns an array of elements in proper sequenceReturn value - Array of all elements in the list in proper sequence
String toString()Returns a String representation of the array elements collectionReturn value - String of array elements separated by comma and space and enclosed within []
void trimToSize()Trims the size of ArrayList instance to current list size
READ  Operators in Java

Java ArrayList Generic and Non-Generic Declaration

Before JDK 1.5, the Java Collection framework was generic as described below.

ArrayList al = new ArrayList(); –> List can hold any type of element

After JDK 1.5, it supports non-generic which can be used as below. We can specify the element type within <>.

ArrayList<String> al = new ArrayList<String>(); –> List can contain only String values

ArrayList<Integer> al = new ArrayList<Integer>(); –> List can contain only Integer value

Java ArrayList Exceptions

ArrayList in Java throws below exceptions:

  • UnsupportedOperationException – when the operation is not supported
  • IndexOutofBoundsException – when invalid index is specified (fromIndex<0 or fromIndex> toIndex or toIndex>size)
  • ClassCastException – when the class of the specified element prevents to add it to the list
  • NullPointerException – when the specified element is null and the list does not allow to add null elements
  • IllegalArgumentException – when some property of the element prevents to add to the list

Example: Creating ArrayList and add elements and collection

First, we create an ArrayList in Java of type String and then add elements to the list. Then we add a new element at index 1. Thus, the element which was previously present at index 1 will move sequentially to the right. The index in an array always starts at 0.

Next, we create a new list with 2 elements and add the entire collection to list 1 at index 1.

import java.util.ArrayList;

public class ArrayListDemo {

  public static void main(String[] args) {
    //Create a String ArrayList
    ArrayList<String> al = new ArrayList<String>();
    
    //Add elements
    al.add("Java");
    al.add("JavaScript");
    al.add("PHP");

    System.out.println("Element in the list1:");
    System.out.println(al);
    
    //Add element at index 1
    al.add(1, "C");
    
    System.out.println("After adding element at index 1: ");
    System.out.println(al);
    
    //Create list2
    ArrayList<String> list = new ArrayList<String>();
    list.add("C++");
    list.add("Ruby");
    System.out.println("Elements in list2:");
    System.out.println(list);
    
    //Add list2 elements in list1
    al.addAll(1, list);
    System.out.println("Elements in List 1 after adding list2:");
    System.out.println(al);
    
  }

}

Output:
Element in the list1:
[Java, JavaScript, PHP]
After adding element at index 1: 
[Java, C, JavaScript, PHP]
Elements in list2:
[C++, Ruby]
Elements in List 1 after adding list2:
[Java, C++, Ruby, C, JavaScript, PHP]

Example: Modifying and Removing an element from ArrayList

Below is an example program to modify the array list and remove an element from ArrayList in Java.

import java.util.ArrayList;
public class ArrayListDemo2 {

  public static void main(String[] args) {
    //Create an Integer ArrayList
    ArrayList<Integer> numbers = new ArrayList<Integer>();
    numbers.add(4);
    numbers.add(8);
    numbers.add(2);
    
    System.out.println("Elements in the list are: ");
    System.out.println(numbers);
    
    //Modify element
    numbers.set(1, 6);
    
    System.out.println("After modifying an element at index 1:");
    System.out.println(numbers);
    
    //Remove an element
    numbers.remove(2);
    
    System.out.println("After removing an element at index 2:");
    System.out.println(numbers);
  }

}
Output:
Elements in the list are: 
[4, 8, 2]
After modifying an element at index 1:
[4, 6, 2]
After removing an element at index 2:
[4, 6]

Example: Other useful methods

The below example illustrates the usage of contains(), indexOf() and retainAll() methods which are part of the ArrayList.

import java.util.ArrayList;
public class ArrayListDemo4 {

  public static void main(String[] args) {
    ArrayList<String> letters = new ArrayList<String>();
    letters.add("A");
    letters.add("G");
    letters.add("R");
    System.out.println(letters.contains("U"));
    int i = letters.indexOf("G");
    System.out.println("Index of G is " + i);
    
    ArrayList<String> c = new ArrayList<String>();
    c.add("F");
    c.add("E");
    c.add("T");
    c.add("P");
    letters.addAll(c);
    System.out.println("Elements in the list after using addAll:");
    System.out.println(letters);
    letters.retainAll(c);
    System.out.println("Elements in the list after using retainAll:");
    System.out.println(letters);


  }

}
Output:
false
Index of G is 1
Elements in the list after using addAll:
[A, G, R, F, E, T, P]
Elements in the list after using retainAll:
[F, E, T, P]

Example: isEmpty() and clear()

The below example clearly shows the result of using isEmpty() and clear() methods in ArrayList

import java.util.ArrayList;
public class ArrayListDemo5 {

  public static void main(String[] args) {
    ArrayList<String> s = new ArrayList<String>();
    s.add("India");
    s.add("US");
    s.add("Germany");
    System.out.println("Contents in list:");
    System.out.println(s);
    System.out.println("Result of calling isEmpty(): " + s.isEmpty());
    s.clear();
    System.out.println("Contents in list after calling clear(): " + s);
    System.out.println("Result of calling isEmpty() after clear: " + s.isEmpty());
  }

}
Contents in list:
[India, US, Germany]
Result of calling isEmpty(): false
Contents in list after calling clear(): []
Result of calling isEmpty() after clear: true

Example: ensureCapacity()

This method ensures that the Java ArrayList can hold a minimum number of elements. This can be used for a dynamically growing array size.

import java.util.ArrayList;
public class ArrayListDemo6 {

  public static void main(String[] args) {
    ArrayList al = new ArrayList();
    al.add("Mango");
    al.add("Guava");
    al.add("Apple");
    al.ensureCapacity(3);
    System.out.println("Array list can store minimum of 3 elements");
    al.add("Orange");
    System.out.println(al);
  }

}
Output:
Array list can store minimum of 3 elements
[Mango, Guava, Apple, Orange]

Ways to iterate or traverse through an ArrayList

We can iterate through an ArrayList in Java using any one of the below methods:

READ  Inheritance in Java

Get elements using for loop

Here, we use for loop to retrieve array elements and print them in output.

import java.util.ArrayList;
public class ArrayListDemo3 {

  public static void main(String[] args) {
    
    ArrayList<String> list = new ArrayList<String>();
    list.add("Ramesh");
    list.add("Banu");
    list.add("Priya");
    list.add("Karthik");

    int size = list.size();
    System.out.println("Size of list is : " + size);
    for(int i=0;i<size;i++)
    {
      System.out.println(list.get(i));
    }
  }

}
Output:
Size of list is : 4
Ramesh
Banu
Priya
Karthik

 Get elements using For each loop

We can also use the for-each loop to get the array elements as described below.

import java.util.ArrayList;
public class ArrayListDemo3 {

  public static void main(String[] args) {
    
    ArrayList<String> list = new ArrayList<String>();
    list.add("Ramesh");
    list.add("Banu");
    list.add("Priya");
    list.add("Karthik");

    for(String s: list)
    {
      System.out.println(s);
    }
  }

}
Output:
Ramesh
Banu
Priya
Karthik

Traverse using Iterator and ListIterator

Iterator and ListIterator are other methods of traversing through array elements in Java ArrayList. For this, we first create an ArrayList and use that object to create an iterator object or ListIterator object. We can then use the in-built methods like next() to get the elements by iterating using while loop. We can also traverse backward, by using the previous() method.

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class ArrayListIterator {

  public static void main(String[] args) {
    ArrayList<String> cities = new ArrayList<String>();
    cities.add("Bangalore");
    cities.add("Chennai");
    cities.add("Delhi");
    cities.add("Mumbai");
    cities.add("Hyderabad");
    
    System.out.println("Traversing forward using iterator");
    Iterator<String> it = cities.iterator();
    while(it.hasNext()) {
      System.out.println(it.next());
    }
    
    System.out.println("\nTraversing reverse using listiterator");
    ListIterator<String> li = cities.listIterator(cities.size());
    while(li.hasPrevious()) {
      System.out.println(li.previous());
    }
    
  }

}
Output:
Traversing forward using iterator
Bangalore
Chennai
Delhi
Mumbai
Hyderabad

Traversing reverse using listiterator
Hyderabad
Mumbai
Delhi
Chennai
Bangalore

Sort an ArrayList

We can sort elements in the array list using the Java Collection framework’s sort method as illustrated below. Here we are sorting integer numbers present in the ArrayList.

import java.util.ArrayList;
import java.util.Collections;

public class ArrayListSort {

  public static void main(String[] args) {
    ArrayList<Integer> i = new ArrayList<Integer>();
    i.add(5);
    i.add(1);
    i.add(10);
    i.add(3);
    i.add(8);
    System.out.println("Before Sorting");
    for(int num : i)
      System.out.println(num);
    Collections.sort(i);
    System.out.println("After Sorting");
    for(int numbers : i)
      System.out.println(numbers);
  }

}
Output:
Before Sorting
5
1
10
3
8
After Sorting
1
3
5
8
10

Java ArrayList example of user-defined objects

We can also use ArrayList to store user-defined objects. The below example shows how we store the Employee class object in an ArrayList. Using this, you can add elements to the ArrayList.

import java.util.ArrayList;
import java.util.Iterator;
class Employee
{
  int empid;
  String empname;
  String empdesignation;
  
  Employee(int empid,String empname,String empdesignation)
  {
    this.empid = empid;
    this.empname = empname;
    this.empdesignation = empdesignation;
  }
}
public class ArrayListObject {

  public static void main(String[] args) {
    //Create Employee class objects
    Employee e1 = new Employee(100,"Rohit","Developer");
    Employee e2 = new Employee(200,"Shyam","Tester");
    Employee e3 = new Employee(205,"Tarun","Trainee");
    
    //Create an arraylist
    ArrayList<Employee> list = new ArrayList<Employee>();
    
    //Add employee objects to the list
    list.add(e1);
    list.add(e2);
    list.add(e3);
    
    //Declare iterator
    Iterator i = list.iterator();
    while(i.hasNext()) {
      //Convert to Employee object to access the elements
      Employee emp = (Employee)i.next();
      System.out.println(emp.empid + " " + emp.empname + " " + emp.empdesignation);
    }
    

  }

}
Output:
100 Rohit Developer
200 Shyam Tester
205 Tarun Trainee

Conclusion

This tutorial discusses in detail about ArrayList in Java, its methods, and how to fetch array elements from the array along with example programs.

READ  Polymorphism in Java

Reference

Array Interview Questions
Graph Interview Questions
LinkedList Interview Questions
String Interview Questions
Tree Interview Questions