ArrayList

ArrayList is one of the most widely used classes in the Java Collections Framework. It is a resizable array implementation of the List interface, providing fast random access and flexible sizing. This is a very high-frequency interview topic.

What Is ArrayList?

• Resizable array implementation of List
• Maintains insertion order
• Allows duplicate elements
• Allows multiple null values
• Part of java.util package

ArrayList<String> list = new ArrayList<>();
          

Position in Collection Hierarchy

Iterable
   └── Collection
        └── List
             └── ArrayList
          

Key Characteristics of ArrayList

• Backed by a dynamic array
• Fast random access (O(1))
• Slower insertions/deletions in middle
• Not synchronized (not thread-safe)

How ArrayList Works Internally (Interview Favorite)

• Uses an internal Object[] array
• Default capacity = 10
• Grows by 50% when capacity is exceeded
• Old array copied into a new larger array

Creating an ArrayList

1️⃣ Default Constructor

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

2️⃣ With Initial Capacity

ArrayList<Integer> list = new ArrayList<>(50);
          

✔ Improves performance when size is known

3️⃣ From Another Collection

ArrayList<Integer> list = new ArrayList<>(existingList);
          

Commonly Used Methods

Adding Elements

list.add(10);
list.add(1, 20);
          

Accessing Elements

int value = list.get(0);
          

Updating Elements

list.set(0, 100);
          

Removing Elements

list.remove(0);       // by index
list.remove(Integer.valueOf(10)); // by value
          

Size and Search

list.size();
list.contains(20);
list.indexOf(20);
          

Iterating an ArrayList

Using for-each loop

for (Integer i : list) {
    System.out.println(i);
}
          

Using Iterator

Iterator<Integer> it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}
          

Using ListIterator

ListIterator<Integer> li = list.listIterator();
          

Performance Complexity (Important)

ArrayList vs Array (Quick Comparison)

Thread Safety

• ArrayList is not synchronized
• Not safe for concurrent modification

Thread-safe Alternatives: Collections.synchronizedList(), CopyOnWriteArrayList

Common Beginner Mistakes

• Using ArrayList in multi-threaded context without synchronization
• Removing elements in loop incorrectly
• Forgetting generics
• Frequent insertions in middle
• Using raw ArrayList type

Interview-Ready Answers

Short Answer

ArrayList is a resizable array implementation of the List interface.

Detailed Answer

In Java, ArrayList is a dynamic array-based implementation of the List interface. It allows duplicates, maintains insertion order, and provides fast random access. It is not synchronized and is best suited for scenarios with frequent read operations.

ArrayList Examples (Top Interview Patterns)

1. Creating an ArrayList

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Selenium");
        System.out.println(list);
    }
}
          

Output

[Java, Selenium]
          

2. ArrayList Allows Duplicate Values

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(10);
        System.out.println(list);
    }
}
          

Output

[10, 10]
          

3. Maintains Insertion Order

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(3);
        list.add(1);
        list.add(2);
        System.out.println(list);
    }
}
          

Output

[3, 1, 2]
          

4. Accessing Elements by Index

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
        System.out.println(list.get(1));
    }
}
          

Output

B
          

5. Modifying Elements using set()

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>(Arrays.asList("Java", "API"));
        list.set(1, "Selenium");
        System.out.println(list);
    }
}
          

Output

[Java, Selenium]
          

6. Removing Element by Index

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
        list.remove(0);
        System.out.println(list);
    }
}
          

Output

[B, C]
          

7. Removing Element by Object

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
        list.remove("B");
        System.out.println(list);
    }
}
          

Output

[A, C]
          

8. remove(int) vs remove(Object) (Very Important)

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>(Arrays.asList(10, 20, 30));
        list.remove(1);                  // removes index 1
        // list.remove(Integer.valueOf(20)); // removes value
        System.out.println(list);
    }
}
          

Output

[10, 30]
          

9. Iterating Using for-each Loop

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>(Arrays.asList("X", "Y", "Z"));
        for (String s : list) {
            System.out.println(s);
        }
    }
}
          

10. Iterating Using Iterator

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
        Iterator<Integer> it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}
          

11. Removing While Iterating (Correct Way)

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
        Iterator<Integer> it = list.iterator();
        while (it.hasNext()) {
            if (it.next() == 2) {
                it.remove();
            }
        }
        System.out.println(list);
    }
}
          

Output

[1, 3]
          

12. ArrayList Size

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>(Arrays.asList("A", "B"));
        System.out.println(list.size());
    }
}
          

Output

2
          

13. Checking Element Existence

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>(Arrays.asList("Java", "API"));
        System.out.println(list.contains("Java"));
    }
}
          

Output

true
          

14. Sorting an ArrayList

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>(Arrays.asList(3, 1, 2));
        Collections.sort(list);
        System.out.println(list);
    }
}
          

Output

[1, 2, 3]
          

15. Custom Sorting using Comparator

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>(Arrays.asList("Java", "API", "Test"));
        list.sort((a, b) -> a.length() - b.length());
        System.out.println(list);
    }
}
          

Output

[API, Test, Java]
          

16. Converting Array to ArrayList

import java.util.*;

class Demo {
    public static void main(String[] args) {
        String[] arr = {"A", "B"};
        ArrayList<String> list = new ArrayList<>(Arrays.asList(arr));
        System.out.println(list);
    }
}
          

17. Converting ArrayList to Array

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>(Arrays.asList("A", "B"));
        Object[] arr = list.toArray();
        System.out.println(arr.length);
    }
}
          

18. ensureCapacity() (Performance)

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.ensureCapacity(1000);
        System.out.println("Capacity ensured");
    }
}
          

Explanation

Reduces resizing overhead

19. Thread-Unsafe Nature of ArrayList

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Not Thread Safe");
        System.out.println(list);
    }
}
          

Explanation

Use Collections.synchronizedList() or CopyOnWriteArrayList

20. Interview Summary – ArrayList

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Ordered");
        list.add("Dynamic");
        list.add("Duplicate");
        System.out.println(list);
    }
}
          

Key Points

• Dynamic array
• Index-based access (fast)
• Allows duplicates
• Maintains insertion order
• Not thread-safe

Key Takeaway

Use ArrayList when fast access and iteration are required. Avoid it when frequent insertions/deletions in the middle or thread safety is a concern.