ArrayList in Java (original) (raw)

Last Updated : 12 Mar, 2025

Try it on GfG Practice

**Java ArrayList is a part of the **collections framework and it is a class of java.util package. It provides us with dynamic-sized arrays in Java.

• The main **advantage of ArrayList is that, unlike normal arrays, we don’t need to mention the size when creating ArrayList. It automatically adjusts its capacity as elements are added or removed.
• It may be slower than standard arrays, but it is helpful when the size is not known in advance. Note that creating a large fixed-sized array would cause a waste of space.
• Since ArrayList is part of the collections framework, it has better interoperability with other collections. For example, conversion to a HashSet is straightforward.
• With generics, ArrayList<T> ensures type safety at compile-time.

**Example:

Java `

// Java Program to demonstrate ArrayList import java.util.ArrayList;

class Main { public static void main (String[] args) {

      // Creating an ArrayList
      ArrayList<Integer> a = new ArrayList<Integer>();
      
      // Adding Element in ArrayList
      a.add(1);
      a.add(2);
      a.add(3);
  
      // Printing ArrayList
      System.out.println(a);
      
}

}

`

Table of Content

• Syntax of ArrayList
• Constructors in ArrayList in Java
• Operations in ArrayList
• Java ArrayList Methods

ArrayList is a Java class implemented using the List interface. Java ArrayList, as the name suggests, provides the functionality of a dynamic array where the size is not fixed as an array. Also, as a part of Collections framework, it has many features not available with arrays.

Syntax of ArrayList

ArrayList arr = new ArrayList();

**Note: You can also create a generic ArrayList

**Important Features of ArrayList in Java

• ArrayList inherits AbstractList class and implements the List interface.
• ArrayList is initialized by size. However, the size is increased automatically if the collection grows or shrinks if the objects are removed from the collection.
• Java ArrayList allows us to randomly access the list.
• ArrayList can not be used for primitive types, like int, char, etc. We need a wrapper class for such cases.
• ArrayList in Java can be seen as a vector in C++.
• ArrayList is not Synchronized. Its equivalent synchronized class in Java is Vector.

Let’s understand the **Java ArrayList in depth. Look at the below image:

In the above illustration, AbstractList, CopyOnWriteArrayList, and AbstractSequentialList are the classes that implement the list interface. A separate functionality is implemented in each of the mentioned classes. They are:

1. **AbstractList: This class is used to implement an unmodifiable list, for which one needs to only extend this AbstractList Class and implement only the _get() and the _size() methods.
2. **CopyOnWriteArrayList: This class implements the list interface. It is an enhanced version of ArrayList in which all the modifications(add, set, remove, etc.) are implemented by making a fresh copy of the list.
3. **AbstractSequentialList: This class extends AbstractList. This class is used to provide the skeletal implementation for lists that are accessed sequiencially (i.e iterators) to create a concrete class. It can implement the get(int index) and size() methods.

**Constructors in ArrayList in Java

In order to Create an ArrayList, we need to create an object of the ArrayList class. The ArrayList class consists of various constructors which allow the possible creation of the array list. The following are the constructors available in this class:

Operations in ArrayList

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

Java `

// Java Program Example to Demonstrate // Addition, Deletion and Updation of Element import java.util.*;

class Main { public static void main(String args[]){

    // Creating an Array of string type
    ArrayList<String> al = new ArrayList<>();
  
      // 1. Addition

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

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

      System.out.println("After Adding element at index 1 : "+ al);
      
      // 2. Deletion of Element
      
      // 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 Values
      
      // Updating value at index 0
      al.set(0, "GFG");
      
  
    // Printing all the elements in an ArrayList
    System.out.println("List after updation of value : "+al);
}

}

`

Output

Orignal 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]

Let us understand how the three operations performed in above Program works.

**1. Adding Elements in ArrayList

Adding elements seems bit complex when the size of ArrayList is not defined:

• Creates a bigger-sized memory on heap memory (for example memory of double size).
• Copies the current memory elements to the new memory.
• The new item is added now as there is bigger memory available now.
• Delete the old memory.

**Set initial capacity when possible: Each time the list exceeds its capacity, it resizes by 50%. This resizing can be costly.
**Avoid Frequent Resizing: Each resize involves creating a new array and copying all existing elements to it.

**2. Changing Elements in ArrayList

After adding the elements, if we wish to change the element, it can be done using the set() method. Since an ArrayList is indexed, the element which we wish to change is referenced by the index of the element. Therefore, this method takes an index and the updated element which needs to be inserted at that index.

**3. Removing Elements in ArrayList

In order to remove an element from an ArrayList, we can use the remove() method. This method is overloaded to perform multiple operations based on different parameters.

**Java ArrayList Methods

**Some Key Points of ArrayList in Java

1. ArrayList is Underlined data Structure Resizable Array or Growable Array.
2. ArrayList Duplicates Are Allowed.
3. Insertion Order is Preserved.
4. Heterogeneous objects are allowed.
5. Null insertion is possible.

Complexity of Java ArrayList

Below are the advantages and disadvantages of using ArrayList in Java:

Advantages of Java ArrayList

• **Dynamic size: ArrayList can dynamically grow and shrink in size, making it easy to add or remove elements as needed.
• **Easy to use: ArrayList is simple to use, making it a popular choice for many Java developers.
• **Fast access: ArrayList provides fast access to elements, as it is implemented as an array under the hood.
• **Ordered collection: ArrayList preserves the order of elements, allowing you to access elements in the order they were added.
• **Supports null values: ArrayList can store null values, making it useful in cases where the absence of a value needs to be represented.

Disadvantages of Java ArrayList

• **Slower than arrays: ArrayList is slower than arrays for certain operations, such as inserting elements in the middle of the list.
• **Increased memory usage: ArrayList requires more memory than arrays, as it needs to maintain its dynamic size and handle resizing.
• **Not thread-safe: ArrayList is not thread-safe, meaning that multiple threads may access and modify the list concurrently, leading to potential race conditions and data corruption.
• **Performance degradation: ArrayList’s performance may degrade as the number of elements in the list increases, especially for operations such as searching for elements or inserting elements in the middle of the list.