ArrayList in Java is a resizable array provided in the java.util package. Unlike normal arrays, its size can grow or shrink dynamically as elements are added or removed.

• Elements can be accessed using their indices, similar to arrays.
• Duplicates are allowed.
• Elements are stored in the order they are inserted.
• ArrayList is not thread-safe. To make it thread-safe, we must wrap it manually using Collections.synchronizedList().

import java.util.ArrayList;

class Main {
    public static void main (String[] args) {
        
      	// Creating an ArrayList
      	ArrayList<Integer> a = new ArrayList<>();
      	
      	// Adding Element in ArrayList
      	a.add(1);
      	a.add(2);
      	a.add(3);
      
      	// Printing ArrayList
      	System.out.println(a);
    }
}

[1, 2, 3]

Explanation: This program creates an ArrayList of integers, adds elements to it using the add() method, and stores them dynamically. Finally, it prints the elements in insertion order as [1, 2, 3].

Note: ArrayList cannot hold primitive types like int, double, or char directly. we must use their wrapper classes instead:

• Use Integer instead of int
• Use Double instead of double
• Use Character instead of char

Hierarchy of ArrayList

It implements List Interface which is a sub-interface of Collection Interface.

ArrayList Constructors in Java

Java provides multiple constructors to create an ArrayList based on different requirements:

1. ArrayList()

Creates an empty ArrayList with default initial capacity.

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

2. ArrayList(Collection<? extends E> c)

Creates an ArrayList initialized with elements from the specified collection.

ArrayList<String> arr = new ArrayList<>(collection);

3. ArrayList(int initialCapacity)

This constructor is used to build an array list with the initial capacity being specified.

ArrayList<Double> arr = new ArrayList<>(20);

Operations of ArrayList

Now, Using the constructors we have got ArrayList for further operations like Insertion,Deletion and Updation of the elements in ArrayList.

import java.util.*;

class GFG{
    
    public static void main(String args[]){
      
        // Creating an Array of string type
        ArrayList<String> al = new ArrayList<>();

        // 1. Adding elements to ArrayList at the end
        al.add("Geeks");
        al.add("Geeks");

      	System.out.println("Original List : "+al);
      	
      	// Adding Elements at the specific index
        al.add(1, "For");

      	System.out.println("After Adding element at index 1 : "+ al);
      	
      	// 2. Removing Element using index
      	al.remove(0);
      
      	System.out.println("Element removed from index 0 : "+ al);
      	
      	// Removing Element using the value
      	al.remove("Geeks");
      
      	System.out.println("Element Geeks removed : "+ al);
      	
      	// 3. Updating value at index 0
      	al.set(0, "GFG");
      
        System.out.println("List after updation of value : "+al);
    }
}

Original List : [Geeks, Geeks]
After Adding element at index 1 : [Geeks, For, Geeks]
Element removed from index 0 : [For, Geeks]
Element Geeks removed : [For]
List after updation of value : [GFG]

Internal Implementation:

Internally an ArrayList uses a dynamically resizable array to store elements.

• Dynamic Array Structure: An ArrayList is internally implemented using a dynamic array (usually an Object[] array). This array stores all the elements of the list.
• Automatic Resizing: When the internal array becomes full, the ArrayList automatically increases its capacity by creating a new larger array and copying the existing elements into it.
• Index-Based Access: Elements are stored in contiguous memory locations, allowing fast access using indexes (e.g., get(index)), typically in O(1) time complexity.
• Element Shifting on Insert/Delete: When an element is added or removed at a specific index, the elements after that position are shifted to maintain order.
• Default Capacity:When an ArrayList is created using the default constructor, its default capacity is 10.

• New Capacity Calculation: The new capacity is calculated using the formula: New Capacity = Old Capacity + (Old Capacity / 2).
  This increases the capacity by 50% of the old capacity.

Capacity vs Size Management

ArrayList maintains two values:

• Size: number of elements currently stored
• Capacity: total length of the internal array that can hold elements before resizing is required.

Complexity of Java ArrayList

Methods of ArrayList

Below down are the list of ArrayList Methods.