ArrayList in Java

Try it on GfG Practice

In Java, an ArrayList is a resizable array implementation that is part of the java.util package. Unlike regular arrays, you don’t need to specify its size in advance; it can grow or shrink dynamically as elements are added or removed.

Key Features

• Resizable Array: ArrayList can automatically grow dynamically in size.
• Indexed Access: ArrayList elements can be accessed using indices like arrays.
• Supports Generics: It ensures type safety at compile-time.
• Not Synchronized: ArrayList uses Collections.synchronizedList() for thread safety.
• Allows Null and Duplicates: ArrayList allows both null values and duplicate elements.
• Maintains Insertion Order: Elements are stored in the order they are added.

Example: 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);
    }
}

[1, 2, 3]

Syntax:

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

Note: You can also create a generic ArrayList

Constructors of 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:

1. ArrayList(): This constructor is used to build an empty array list.

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

2. ArrayList(Collection c): This constructor is used to build an array list initialized with the elements from the collection c.

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

3. ArrayList(int capacity): 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.

Example: 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. 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]

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

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.

Java ArrayList Methods

Complexity of Java ArrayList

ArrayList in Java

Visit Course