ArrayList Internal Resizing Mechanism in Java

Direct Answer

When an ArrayList needs more room, it allocates a larger backing array and copies existing references, so that particular append is O(n) while repeated appends are amortized O(1). Current OpenJDK commonly grows by about 50% for ordinary sizes, but the Java API does not guarantee an exact growth factor or expose capacity as part of the List contract.

Code Example

import java.util.ArrayList;
import java.util.List;

public class ArrayListResizeDemo {
    public static void main(String[] args) {
        // Default initial capacity is 10
        List<String> orders = new ArrayList<>();

        // Add 10 elements - no resize yet
        for (int i = 1; i <= 10; i++) orders.add("Order-" + i);

        // 11th element triggers resize: 10 -> 15 (10 + 10/2)
        orders.add("Order-11");

        // Fill to 15 - no resize
        for (int i = 12; i <= 15; i++) orders.add("Order-" + i);

        // 16th element triggers resize: 15 -> 22 (15 + 15/2)
        orders.add("Order-16");

        // If you know the size upfront, pre-size to avoid resizes
        List<String> bulk = new ArrayList<>(1000);
        for (int i = 0; i < 1000; i++) bulk.add("Order-" + i); // no resizes
    }
}

Common Mistakes & Pitfalls

• Saying ArrayList doubles capacity: Freshers assume it doubles like Vector (2x), but ArrayList currently grows by about 50 percent for ordinary sizes — an implementation-specific growth calculation, which equals oldCapacity times 1.5.
• Claiming add is always O(1): The correct term is amortized O(1). An individual add that triggers a resize is O(n) because all elements get copied, but resizes are rare enough that the average stays constant.
• Ignoring initial capacity in tight loops: Building large lists inside a hot method (like a controller handling thousands of requests per second) without setting initial capacity makes every request pay the resize penalty.