ArrayList

🔍 What Is It?

ArrayList is java.util.List backed by a dynamic array (Object[]).

Key Characteristics:

• →Random access: O(1) — direct array index
• →Add at end: O(1) amortized — occasionally O(n) for resize
• →Add/remove in middle: O(n) — must shift elements
• →Search (contains): O(n) — must scan entire array
• →Memory: contiguous memory — excellent CPU cache performance

Capacity vs Size:

• →size() — number of elements currently stored
• →capacity — size of the internal array (always >= size)
• →Initial capacity: 10 (or specified in constructor)
• →Growth factor: 1.5x (new capacity = old * 3/2 + 1)

Constructors:

• →new ArrayList<>() — initial capacity 10
• →new ArrayList<>(initialCapacity) — pre-allocate
• →new ArrayList<>(collection) — copy from collection

🎯 Why Do We Need It?

ArrayList is the workhorse of Java collections. It combines the simplicity of arrays (fast random access, contiguous memory) with the flexibility of dynamic sizing. In enterprise code, you use it to hold query results, build response objects, accumulate items, and pass data between layers.

🏗️ What Happens in Real Projects?

ArrayList is used in every Java project:

• →Query results: List<Order> orders = new ArrayList<>(orderRepository.findAll())
• →Building responses: accumulate items then return
• →Batch processing: collect items then process in bulk
• →Sorting: ArrayList.sort() is highly optimized (TimSort)

⚙️ How It Works

How Resizing Works:

Initial: [_, _, _, _, _, _, _, _, _, _]  // capacity 10, size 0
After 10 adds: [a, b, c, d, e, f, g, h, i, j]  // capacity 10, size 10
11th add triggers resize:
  1. Create new array of size 15 (10 * 3/2 + 1)
  2. Copy all 10 elements to new array
  3. Add 11th element
  4. Old array becomes garbage

Why O(1) amortized for add:

Each element is copied at most once per resize. Total copies for n elements = n/2 + n/4 + ... = n. So average copies per element = 1. Hence O(1) amortized.

trimToSize():

Reduces internal array to exactly size(). Use after bulk loading to free unused capacity.

💻 Example

ArrayList Best Practices — How to use ArrayList efficiently in production code.

// Pre-size when you know the approximate count
// Avoids multiple resize operations
public List<ProductDto> convertToDto(List<Product> products) {
    List<ProductDto> dtos = new ArrayList<>(products.size());  // exact size
    for (Product p : products) {
        dtos.add(new ProductDto(p.getId(), p.getName(), p.getPrice()));
    }
    return dtos;
}

// Efficient bulk add
List<String> result = new ArrayList<>();
result.addAll(firstBatch);   // more efficient than adding one by one
result.addAll(secondBatch);

// removeIf — efficient in-place removal (avoids ConcurrentModificationException)
List<Order> orders = new ArrayList<>(fetchOrders());
orders.removeIf(order -> order.getStatus() == OrderStatus.CANCELLED);

// replaceAll — in-place transformation
List<String> names = new ArrayList<>(List.of("alice", "bob", "charlie"));
names.replaceAll(String::toUpperCase);
// [ALICE, BOB, CHARLIE]

// Sort with Comparator
List<Employee> employees = getEmployees();
employees.sort(Comparator
    .comparing(Employee::getDepartment)
    .thenComparing(Employee::getName));

// Efficient contains check for large lists — use Set instead
List<String> bigList = new ArrayList<>(100_000);
// BAD: O(n) per check
boolean found = bigList.contains("target");
// GOOD: convert to Set first if doing many contains checks
Set<String> lookupSet = new HashSet<>(bigList);
boolean fastFound = lookupSet.contains("target");  // O(1)

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits