Introduction to ArrayList in Java 📘
When beginners start learning Java, they usually begin with arrays. Arrays are powerful, but they come with a major limitation — fixed size. Once an array is created, its size cannot be changed.
This is where ArrayList comes into the picture 💡.
An ArrayList is a part of Java’s Collection Framework and provides a dynamic array, meaning it can grow and shrink automatically during runtime. It makes Java programming more flexible, readable, and efficient.
This article will explain everything about ArrayList — from basics to internals, common mistakes, confusing behaviors, tricky code examples, and best practices — in a way that beginners can truly understand.
What is an ArrayList? 🧠
An ArrayList is a resizable array implementation of the List interface.
In simple terms:
- It behaves like an array
- But its size is not fixed
- It provides many built-in methods for data manipulation
ArrayList is present in the java.util package.
Why Do We Need ArrayList Instead of Arrays? 🤔
Arrays have several limitations:
- ❌ Fixed size
- ❌ No built-in methods for add/remove
- ❌ Manual resizing required
- ❌ Less flexible
ArrayList solves these problems:
- ✅ Dynamic size
- ✅ Easy insertion and deletion
- ✅ Rich API methods
- ✅ Cleaner and safer code
Important Characteristics of ArrayList ⭐
- Stores objects only
- Maintains insertion order
- Allows duplicate values
- Allows multiple null values
- Index starts from 0
- Internally uses an array
- Not synchronized (not thread-safe by default)
Internal Working of ArrayList (Very Important) ⚙️
Internally, ArrayList uses a normal array.
Key points:
- Default initial capacity is 10
- When the array becomes full:
- A new array is created
- Capacity increases by 50%
- Old elements are copied to the new array
⚠ Resizing is expensive, so initial capacity matters for performance.
Importing ArrayList 📦
import java.util.ArrayList;
Without this import, the compiler will throw an error.
Creating an ArrayList 🏗️
ArrayList list = new ArrayList();
⚠ This creates a raw ArrayList and is not recommended.
Using Generics with ArrayList (Must Know) 🔒
ArrayList<Integer> numbers = new ArrayList<>();
Benefits:
- Type safety
- No casting
- Compile-time error checking
Common Mistake: Using Primitive Data Types ❌
❌ Wrong:
ArrayList<int> list = new ArrayList<>();
✔ Correct:
ArrayList<Integer> list = new ArrayList<>();
ArrayList works only with wrapper classes.
Adding Elements to ArrayList ➕
ArrayList<String> names = new ArrayList<>();
names.add("Ajay");
names.add("Rahul");
names.add("Neha");
Elements are added at the end by default.
Adding Element at a Specific Index 📍
names.add(1, "Amit");
Elements shift to the right.
⚠ Invalid index causes IndexOutOfBoundsException.
Accessing Elements from ArrayList 👀
String name = names.get(0);
Index must be within range.
Updating Elements in ArrayList ✏️
names.set(1, "Rohit");
Replaces the existing value at the index.
Removing Elements from ArrayList 🗑️
By index:
names.remove(0);
By value:
names.remove("Neha");
⚠ Very common confusion:
ArrayList<Integer> list = new ArrayList<>();
list.add(10);
list.add(20);
list.remove(10); // ❌ tries to remove index 10
list.remove(Integer.valueOf(10)); // ✔ removes value 10
Size vs Length Confusion 😵
✔ Correct:
list.size();
❌ Wrong:
list.length; // for arrays only
Checking If ArrayList Is Empty 📭
list.isEmpty();
Checking If Element Exists 🔍
list.contains(20);
Uses equals() method internally.
Traversing ArrayList Using for Loop 🔁
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
Traversing Using Enhanced for Loop 🔂
for (Integer num : list) {
System.out.println(num);
}
⚠ Structural modification not allowed.
Traversing Using Iterator 🧭
Iterator<Integer> itr = list.iterator();
while (itr.hasNext()) {
System.out.println(itr.next());
}
✔ Safe removal using itr.remove().
Common Mistake: Modifying While Iterating ❌
for (Integer num : list) {
list.remove(num); // ❌
}
Throws ConcurrentModificationException.
Duplicate and Null Values in ArrayList 🔄
list.add(10);
list.add(10);
list.add(null);
list.add(null);
✔ Both duplicates and nulls are allowed.
Capacity vs Size (Highly Confusing Topic) 🧩
- Capacity → internal array size
- Size → number of elements stored
ArrayList<Integer> list = new ArrayList<>(50);
Capacity = 50
Size = 0
Setting Initial Capacity (Performance Tip) 🚀
ArrayList<Integer> list = new ArrayList<>(1000);
Reduces resizing cost.
Converting ArrayList to Array 🔄
Integer[] arr = list.toArray(new Integer[0]);
Converting Array to ArrayList 🔁
Integer[] arr = {1, 2, 3};
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(arr));
⚠ Arrays.asList() returns a fixed-size list.
Sorting an ArrayList 📊
Collections.sort(list);
Descending:
Collections.sort(list, Collections.reverseOrder());
ArrayList of Custom Objects 👨🎓
class Student {
int id;
String name;
}
ArrayList<Student> students = new ArrayList<>();
Sorting requires Comparable or Comparator.
ArrayList vs Array ⚔️
- Array → Fixed size, faster
- ArrayList → Dynamic size, flexible
ArrayList vs LinkedList 🔍
- ArrayList → Fast access
- LinkedList → Fast insertion/deletion
Thread Safety in ArrayList 🔐
ArrayList is not thread-safe.
List list = Collections.synchronizedList(new ArrayList<>());
Common Beginner Mistakes Summary ⚠️
- Using
lengthinstead ofsize() - Using primitives instead of wrapper classes
- Confusing
remove(index)andremove(object) - Modifying list during iteration
- Ignoring initial capacity
- Index out of bounds errors
When Should You Use ArrayList? ✅
Use ArrayList when:
- Data size is dynamic
- Fast access is required
- Order matters
- Duplicates are allowed
Conclusion 🎯
ArrayList is one of the most important and frequently used classes in Java. It plays a crucial role in real-world applications, interviews, and competitive programming.
Understanding ArrayList deeply — including its internal working, edge cases, and common mistakes — builds a strong foundation for mastering Java Collections.
Once you are comfortable with ArrayList, learning other collections like LinkedList, HashSet, and HashMap becomes much easier.
Happy Coding! 🚀😊
