ArrayList in Java

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().

[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.

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.