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). In this article, we will see what is ArrayList and how to initialize an ArrayList in Java?
You might also be interested in ArrayList vs LinkedList
Table of Contents
Java ArrayList Hierarchy
Declaring an ArrayList Class in Java
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)
The ArrayList class extends the AbstractList class and implements the List interface.
ArrayList Constructors
We can create ArrayList in Java Constructors in the below 3 methods:
| Constructor | Description |
|---|---|
| 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 the List interface.
| Method | Description | Parameter |
|---|---|---|
| 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 right | index- 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 right | index - 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 element | Return value - true if the list contains the element |
| Boolean containsAll(Collection c) | Checks if the list contains all the elements in the collection | Return 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 order | Return value - true if object elements match with the list |
| Object getIndex(int index) | Retrieves the element at the specified index | index - 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 element | o - The element to be identified Return value - index value |
| Boolean isEmpty() | Checks if the list is empty or not | Return value - true if list contains no values |
| Iterator iterator() | Retrieves the iterator of list in sequence | Return value - Iterator |
| int lastIndexOf(Object o) | Retrieves the last occurrence of the specified object | o - Element to be identified Return value - index value |
| Object remove(int index) | Removes the element at the specified index | index - 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 present | o - 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 present | c - 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 removed | c - 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 passed | o - 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 list | Return value - size of the list |
| List sublist(int fromIndex, int toIndex) | Retrieves the part of the list based on start and endIndex | fromIndex - 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 mentioned | mincapacity - minimum number of elements the arraylist can hold |
| void sort(Comparator c) | Sorts the elements in the list based on the comparator argument | c - compartor which is used to compare the list elements |
| Object[] toArray() | Returns an array of elements in proper sequence | Return value - Array of all elements in the list in proper sequence |
| String toString() | Returns a String representation of the array elements collection | Return 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 |
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
Import ArrayList in Java
Before we start using the ArrayList class, we need to import the relevant package in order to use it. For this, we import the below package to use the ArrayList.
import java.util.ArrayList;
Declare an ArrayList in Java
We can declare an ArrayList in Java by creating a variable of ArrayList type. We can also specify the type of list as either String or Integer, etc. Below is an example of declaring an ArrayList of String and Integer type.
ArrayList<String> colors; ArrayList<Integer> weight;
Create an ArrayList in Java
Once we declare an ArrayList, we can create it by invoking the constructor to instantiate an object and assign it to the variable. We can use any of the constructors as discussed above. We can also declare and create an ArrayList in a single statement as below.
ArrayList<String> colors = new ArrayList<String>();
(OR)
ArrayList<String> colors; //declare an ArrayList colors = new ArrayList<String>(); //create an ArrayList
How to initialize an ArrayList in Java?
Once we declare and create an ArrayList, we can initialize it with the required values. There are several methods to initialize an ArrayList as mentioned below.
Using add() method
One common method to initialize an ArrayList in Java is by using the add() method.
ArrayList<String> colors = new ArrayList<String>();
colors.add("Red");
colors.add("Blue");
colors.add("Green");Using asList() method
We can use the asList() method of the Arrays class while creating an ArrayList. This is another method to initialize an ArrayList.
ArrayList<String> color = new ArrayList<String>(
Arrays.asList("Red","Blue","Green")
);Using List.Of() method
The List.of() method is another way to initialize an ArrayList.
List<String> colors = new ArrayList<>(
List.of("Red","Blue","Green")
);Using another Collection
We can also initialize an ArrayList using the values of another Collection. In the below code, we initialize the data variable with colors ArrayList values.
ArrayList<String> colors = new ArrayList<String>();
colors.add("Red");
colors.add("Blue");
colors.add("Green");
ArrayList<String> data = new ArrayList<String>(colors);Java ArrayList Examples
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]
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]
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]
Clear an ArrayList in java
The below example clearly shows the result of using isEmpty() and clear() methods in ArrayList. Using the clear() method, we can empty the ArrayList by removing all the elements.
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
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 of 3 elements");
al.add("Orange");
System.out.println(al);
}
}
Output: Array list can store minimum of 3 elements [Mango, Guava, Apple, Orange]
Print ArrayList in Java – Iterate or navigate through elements
We can iterate through an ArrayList in Java using any one of the below methods:
- For loop
- For each
- Iterator interface
- ListIterator interface
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 in Java
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 and how to initialize an ArrayList in Java, its methods, and how to fetch array elements from the array along with example programs. You might be interested in Java collection interview questions then go and crack the interviews.