Java ArrayList — 38 Resizes, 225M Copies, Monday OOMs

Every non-trivial Java application manages collections of data — a shopping cart full of products, a feed full of posts, a queue full of tasks. The humble array can do this, but only if you know exactly how many items you'll have before you write a single line of code. In the real world, you almost never do. ArrayList exists precisely because the world is unpredictable, and your code needs to keep up.

ArrayList solves the fixed-size problem of plain arrays by wrapping one internally and automatically resizing it whenever capacity is exhausted. It gives you the fast random access of an array (jump straight to index 7 without touching 0–6) while also letting you add and remove items freely at runtime. That combination — speed plus flexibility — is why ArrayList is the most-used collection class in Java by a significant margin.

By the end you'll understand not just how to declare and populate an ArrayList, but why it resizes the way it does, how that affects performance, when you should reach for something else (like LinkedList or a plain array), and the specific gotchas that cause subtle bugs. You'll also have a handful of interview-ready answers.

Creating and Populating an ArrayList — The Right Way from Day One

Declaring an ArrayList takes one line, but that one line contains decisions that matter more than they look.

First, always use the generic type parameter — ArrayList<String> instead of the raw ArrayList. Without it, Java lets you shove any object in, and the compiler can't warn you when you mix types. You'll get a ClassCastException at runtime instead of a compile-time error, and runtime surprises are the worst kind.

Second, favour the List<String> interface type on the left side of the declaration: List<String> guests = new ArrayList<>(). This is called programming to the interface. It means if you later decide to swap ArrayList for a LinkedList, you change exactly one word. Every method call you wrote still compiles. This is not just an academic best practice — it's the pattern you'll see in every professional codebase.

Third, if you have a rough idea of your list's final size, pass it as the initial capacity: new ArrayList<>(50). This pre-allocates space and avoids the internal resizing penalty we'll dig into shortly. You're not locking in a maximum — you're just giving ArrayList a head start.

package io.thecodeforge.collections;

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

public class GuestListDemo {

    public static void main(String[] args) {

        // Program to the List interface — not ArrayList directly.
        // This keeps your code flexible if you need to swap implementations later.
        List<String> guestList = new ArrayList<>();

        // add() appends to the end of the list — O(1) amortised time
        guestList.add("Alice");
        guestList.add("Bob");
        guestList.add("Charlie");

        // add(index, element) inserts at a specific position — O(n) because
        // everything after that index has to shift one spot to the right
        guestList.add(1, "Zara");  // Zara goes between Alice and Bob

        System.out.println("Guest list: " + guestList);
        System.out.println("Number of guests: " + guestList.size());

        // get(index) retrieves by position — O(1), same speed as a plain array
        String firstGuest = guestList.get(0);
        System.out.println("First guest: " + firstGuest);

        // contains() checks if a value exists — O(n) linear scan under the hood
        boolean isInvited = guestList.contains("Bob");
        System.out.println("Is Bob invited? " + isInvited);
    }
}

How ArrayList Actually Resizes — Why This Changes How You Write Code

This is the section most tutorials skip, and it's exactly where performance bugs hide.

An ArrayList is backed by a plain Object[] array internally. When you create new ArrayList<>() without specifying a capacity, Java allocates an internal array of size 10. The moment you add an 11th element, ArrayList creates a new array that is 50% larger (so size 15), copies all 10 existing elements into it, and then adds your new element. This copy operation is O(n). It happens again at 16, then 24, then 36, and so on.

Most of the time this is invisible because modern hardware is fast. But if you're building a list of 10,000 items inside a tight loop — say, parsing a large CSV file — those repeated copy operations add up. The fix is simple: if you know the approximate final size, pass it to the constructor upfront. You don't need to be exact. Even a rough estimate dramatically reduces the number of resize events.

The key mental model: add() at the end is O(1) amortised (fast on average), but occasionally triggers an O(n) resize. add(index, element) in the middle is always O(n) because elements must shift. get(index) is always O(1). Understanding this lets you write code that stays fast even at scale.

package io.thecodeforge.collections;

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

public class ResizingDemo {

    public static void main(String[] args) {

        // --- Scenario 1: No initial capacity hint ---
        // ArrayList starts with internal array of size 10.
        // Every time we exceed capacity, it resizes (copies everything).
        long startTime = System.nanoTime();

        List<Integer> productIds = new ArrayList<>();
        for (int i = 0; i < 100_000; i++) {
            productIds.add(i);  // triggers multiple internal resizes
        }

        long durationWithoutHint = System.nanoTime() - startTime;

        // --- Scenario 2: With initial capacity hint ---
        // We tell ArrayList we expect ~100,000 items.
        // It allocates space upfront — zero resize operations.
        startTime = System.nanoTime();

        List<Integer> productIdsOptimised = new ArrayList<>(100_000);
        for (int i = 0; i < 100_000; i++) {
            productIdsOptimised.add(i);  // no resizing, just writing into pre-allocated space
        }

        long durationWithHint = System.nanoTime() - startTime;

        System.out.println("Without capacity hint: " + durationWithoutHint / 1_000_000 + " ms");
        System.out.println("With capacity hint:    " + durationWithHint / 1_000_000 + " ms");

        // trimToSize() releases any unused allocated slots — useful after
        // you've finished building a list that will now be read-only
        ((ArrayList<Integer>) productIdsOptimised).trimToSize();
        System.out.println("Memory trimmed. List size: " + productIdsOptimised.size());
    }
}

Iterating, Removing and Sorting — Real-World Patterns That Don't Break

Iterating an ArrayList seems trivial until you try to remove items while iterating — then it breaks in ways that are genuinely confusing the first time you hit them.

The safest way to iterate is the enhanced for-loop when you're just reading. When you need the index, use a classic for-loop with get(i). When you need to remove items during iteration, you have two good options: use an Iterator explicitly and call iterator.remove(), or use removeIf() with a lambda (available since Java 8). Never call list.remove() inside an enhanced for-loop — that causes a ConcurrentModificationException.

Sorting an ArrayList is one line: Collections.sort(list) for natural ordering, or list.sort(Comparator.comparing(...)) when you need custom logic. The sort is backed by TimSort, an adaptive algorithm that's particularly efficient on partially-sorted data — which is exactly what real-world data tends to be.

For filtering and transformation, streams give you a clean declarative pipeline. They don't modify the original list — they produce a new one. This immutability makes your code much easier to reason about, especially in concurrent contexts.

package io.thecodeforge.collections;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class OrderProcessing {

    record Order(String id, String status, double amount) {}

    public static void main(String[] args) {

        List<Order> orders = new ArrayList<>();
        orders.add(new Order("ORD-001", "PENDING",  149.99));
        orders.add(new Order("ORD-002", "SHIPPED",   59.00));
        orders.add(new Order("ORD-003", "PENDING",  299.50));
        orders.add(new Order("ORD-004", "CANCELLED", 25.00));
        orders.add(new Order("ORD-005", "SHIPPED",  179.99));

        // --- Pattern 1: Enhanced for-loop (read-only) ---
        System.out.println("All orders:");
        for (Order order : orders) {
            System.out.println("  " + order.id() + " — " + order.status());
        }

        // --- Pattern 2: removeIf — safe removal during iteration ---
        // DO NOT call orders.remove() inside a for-each loop.
        // removeIf handles the iterator internally and avoids ConcurrentModificationException.
        orders.removeIf(order -> order.status().equals("CANCELLED"));
        System.out.println("\nAfter removing cancelled orders: " + orders.size() + " remaining");

        // --- Pattern 3: Sort by amount descending ---
        orders.sort(Comparator.comparingDouble(Order::amount).reversed());
        System.out.println("\nOrders by value (highest first):");
        for (Order order : orders) {
            System.out.printf("  %s  $%.2f%n", order.id(), order.amount());
        }

        // --- Pattern 4: Stream to filter into a new list ---
        // The original list is untouched — stream produces a fresh collection
        List<Order> pendingOrders = orders.stream()
                .filter(order -> order.status().equals("PENDING"))
                .collect(Collectors.toList());

        System.out.println("\nPending orders only:");
        pendingOrders.forEach(o -> System.out.println("  " + o.id() + "  $" + o.amount()));
    }
}

ArrayList vs Array — Which One to Use?

The decision between ArrayList and a plain array comes down to three factors: whether the size is fixed, whether you need primitives, and performance requirements.

Size flexibility: Arrays have a fixed length set at creation new int[10]. You cannot add or remove elements. ArrayList grows and shrinks dynamically. If you know the exact number of elements and that count won't change, arrays are simpler and faster. But in most business applications, the size is unknown ahead of time, making ArrayList the default choice.

Type safety: Arrays support primitives (int[], char[]) directly, saving memory and avoiding boxing overhead. ArrayList always works with objects — primitives are autoboxed into wrapper types (Integer, Double, etc.), which adds memory and a small performance cost. For large numeric collections, arrays are significantly more efficient.

Performance: Array access is slightly faster than ArrayList (no method call overhead, no bounds checking beyond what the JVM already does). For read-heavy workloads the difference is negligible. For write-heavy workloads with many add/remove operations in the middle, the difference matters because arrays require manual resizing and shifting.

API convenience: ArrayList provides a rich set of methods (add, remove, contains, sort, stream) that you'd have to implement manually on an array. This reduces boilerplate and bugs.

Memory: Array of 1000 int elements takes ~4KB. ArrayList of 1000 Integer elements takes ~24KB (object headers + reference pointers) plus the array object itself. The overhead is significant.

When to choose array: (1) Fixed size known at compile time. (2) Working with large numbers of primitives (int, long, double). (3) Ultra-low-latency code where every nanosecond counts — though ArrayList is already extremely fast. (4) When you need multidimensional structures with consistent dimensions.

When to choose ArrayList: (1) Size is not known upfront. (2) You need add/remove/contains/sort out of the box. (3) You are storing objects (not primitives) — the overhead of ArrayList vs array of references is minimal. (4) You want to use streams or other modern Java features.

package io.thecodeforge.collections;

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

public class ArrayVsArrayList {

    public static void main(String[] args) {
        // Array: fixed size, primitive friendly
        int[] fixedScores = new int[5];
        fixedScores[0] = 95;
        fixedScores[1] = 82;
        // You cannot add a 6th element — you'd need a new array

        // ArrayList: dynamic, object-based
        List<Integer> dynamicScores = new ArrayList<>();
        dynamicScores.add(95);
        dynamicScores.add(82);
        dynamicScores.add(74);  // no problem, grows automatically

        // Converting between them
        int[] array = {1, 2, 3};
        List<Integer> list = new ArrayList<>();
        for (int value : array) {
            list.add(value);
        }

        // ArrayList to array
        Integer[] arrayFromList = list.toArray(new Integer[0]);

        System.out.println("Array length: " + fixedScores.length);
        System.out.println("List size: " + dynamicScores.size());
    }
}

ArrayList vs LinkedList — When to Choose Which

ArrayList and LinkedList are the two most common List implementations, but they have dramatically different performance characteristics. Choosing the wrong one can make your application an order of magnitude slower.

Random access (get/set): ArrayList provides O(1) random access — direct array indexing. LinkedList requires walking from the head or tail, O(n). If your code frequently reads elements by index, ArrayList is the clear winner.

Insert/delete at ends: ArrayList's add() at end is O(1) amortised (fast). LinkedList's add() at end is O(1) always (just append a node). However, ArrayList's add at beginning is O(n) because all elements shift. LinkedList's add at beginning is O(1). Use LinkedList if you frequently insert or remove at the head of the list — for example, a FIFO queue.

Insert/delete in middle: ArrayList requires shifting elements — O(n). LinkedList requires O(1) if you already have the node (via iterator), but O(n) to find the position otherwise. In practice, LinkedList is slower for middle operations because traversing to the index is O(n) anyway.

Memory: ArrayList stores only the object references in a contiguous array (plus some overhead for unused capacity). LinkedList stores each element as a separate Node object with two extra references (prev, next). For 1 million elements, ArrayList uses ~8 MB (plus capacity overhead), LinkedList uses ~24 MB for nodes alone (plus element overhead). LinkedList also has poor cache locality — traversing nodes follows pointers scattered across heap memory, while ArrayList's contiguous array is CPU-cache-friendly.

Conclusion: Choose ArrayList as the default. Choose LinkedList only when (1) you are adding/removing at both ends frequently, and (2) you never need random access by index. For most real-world applications, ArrayList is faster even when LinkedList's theoretical complexity suggests otherwise, because CPU cache hits matter more than algorithmic complexity.

package io.thecodeforge.collections;

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

public class ListPerformanceDemo {

    public static void main(String[] args) {
        int size = 100_000;

        // ArrayList: add at end
        List<Integer> arrayList = new ArrayList<>();
        long start = System.nanoTime();
        for (int i = 0; i < size; i++) arrayList.add(i);
        System.out.println("ArrayList add end: " + (System.nanoTime() - start) / 1_000_000 + " ms");

        // LinkedList: add at end
        List<Integer> linkedList = new LinkedList<>();
        start = System.nanoTime();
        for (int i = 0; i < size; i++) linkedList.add(i);
        System.out.println("LinkedList add end: " + (System.nanoTime() - start) / 1_000_000 + " ms");

        // Random access (get middle)
        start = System.nanoTime();
        int sum = 0;
        for (int i = 0; i < size; i++) sum += arrayList.get(i);
        System.out.println("ArrayList get: " + (System.nanoTime() - start) / 1_000_000 + " ms");

        start = System.nanoTime();
        sum = 0;
        for (int i = 0; i < size; i++) sum += linkedList.get(i);
        System.out.println("LinkedList get: " + (System.nanoTime() - start) / 1_000_000 + " ms");

        // Insert at beginning
        arrayList.clear();
        start = System.nanoTime();
        for (int i = 0; i < 10_000; i++) arrayList.add(0, i);
        System.out.println("ArrayList insert front: " + (System.nanoTime() - start) / 1_000_000 + " ms");

        linkedList.clear();
        start = System.nanoTime();
        for (int i = 0; i < 10_000; i++) linkedList.add(0, i);
        System.out.println("LinkedList insert front: " + (System.nanoTime() - start) / 1_000_000 + " ms");
    }
}

Advantages and Disadvantages of ArrayList

Every developer should know the trade-offs of ArrayList before using it in production.

Advantages: 1. Fast random access — get(index) is O(1). This is the #1 reason to use ArrayList over other List implementations. 2. Append is fast — add() at end is O(1) amortised. For most workloads, this is the operation you do most. 3. Cache-friendly — elements are stored contiguously in memory, so iterating sequentially is CPU-cache efficient. 4. Rich API — built-in methods for sorting, searching, sublisting, and streaming. 5. Flexible growth — automatically resizes, so you don't need to manage capacity manually (though you should hint it). 6. Serializable — ArrayList implements Serializable, making it easy to persist or send over the network.

Disadvantages: 1. Insert/delete in middle is slow — O(n) because elements shift. If your code frequently inserts or removes from the middle of large lists, ArrayList is a poor choice. 2. No primitives — ArrayList<Integer> boxes each int to an Integer object, increasing memory and GC pressure. For large numeric collections, use primitive arrays or specialised libraries. 3. Not thread-safe — concurrent modifications cause ConcurrentModificationException or data corruption. Must synchronize externally or use CopyOnWriteArrayList. 4. Resizing cost — occasional O(n) resizes cause latency spikes. Pre-sizing mitigates this, but if you can't guess the size, you pay the cost. 5. Unused capacity overhead — the backing array may be larger than the actual size, wasting memory. trimToSize() helps but is not always called. 6. No fast contains for custom objects — contains() does a linear scan using equals(). For large lists, consider HashSet for uniqueness checks.

Verdict: ArrayList is the Swiss Army knife of Java collections — it's good for most tasks, but not all. Understand its limits and you'll choose the right tool every time.

Sorting ArrayList with Comparator — Sort by Name, Price, or Custom Logic

Sorting an ArrayList is trivial with list.sort() or Collections.sort(). When you need a custom order (by name alphabetically, by price descending, by date, etc.), you provide a Comparator.

Java 8 introduced the Comparator.comparing() factory methods, making custom sorting highly readable. You chain methods like .thenComparing() for tie-breaking and .reversed() for descending order.

For simple natural order (String alphabetical, Integer numeric), implement Comparable or use Collections.sort(list). For objects like products, orders, or employees, define a Comparator either as a lambda or using method references.

Important: Sorting modifies the list in place. It does not create a new list. If you need to preserve the original order, copy the list first: new ArrayList<>(original).

Stability: The sort is stable — equal elements maintain their relative order. This matters when you sort by multiple fields: a primary sort (e.g., price) then secondary sort (e.g., name) will keep ties in name order from the original list.

Performance: Sorting is O(n log n) backed by TimSort, which is adaptive — it detects already-sorted runs and performs nearly O(n) on partially sorted data. This is huge for real-world data that's often nearly sorted (e.g., a CSV that's already sorted by ID and you re-sort by date).

package io.thecodeforge.collections;

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

public class SortWithComparator {

    record Product(int id, String name, double price) {}

    public static void main(String[] args) {
        List<Product> products = new ArrayList<>();
        products.add(new Product(3, "Laptop", 999.99));
        products.add(new Product(1, "Mouse", 29.99));
        products.add(new Product(2, "Keyboard", 89.99));
        products.add(new Product(4, "Monitor", 399.99));

        // Sort by name (natural alphabetical)
        products.sort(Comparator.comparing(Product::name));
        System.out.println("By name: " + products);

        // Sort by price descending (most expensive first)
        products.sort(Comparator.comparingDouble(Product::price).reversed());
        System.out.println("By price descending: " + products);

        // Sort by price descending, then by name ascending for ties
        products.sort(Comparator.comparingDouble(Product::price).reversed()
                                .thenComparing(Product::name));
        System.out.println("By price then name: " + products);

        // Using a custom Comparator (lambda)
        Comparator<Product> byPriceAsc = (p1, p2) -> Double.compare(p1.price, p2.price);
        products.sort(byPriceAsc);
        System.out.println("By price ascending (lambda): " + products);

        // Preserve original order: copy first
        List<Product> copy = new ArrayList<>(products);
        copy.sort(Comparator.comparing(Product::id));
        System.out.println("Original unchanged: " + products);
        System.out.println("Sorted copy by id: " + copy);
    }
}

Practice Problems — Test Your ArrayList Knowledge

Working through these problems will solidify your understanding of ArrayList's strengths and pitfalls. Try to solve each one without looking at hints first — then check the concepts they test.

Problem 1: Merge Two Sorted Lists Given two ArrayList<Integer> that are individually sorted in ascending order, merge them into a single sorted ArrayList without using Collections.sort(). This tests your understanding of two-pointer merge and ArrayList's add() with index.

Problem 2: Remove Duplicates in Place Given an ArrayList of integers, remove all duplicate values while preserving the order of first occurrence. Do not use a Set. This tests you on iteration and removal patterns (use Iterator or removeIf).

Problem 3: Rotate the List Write a method that rotates an ArrayList by k positions to the right. For example, [1,2,3,4,5] rotated by 2 becomes [4,5,1,2,3]. Try to do this in O(n) time and O(1) extra space (excluding the list itself). You'll use subList and manual index manipulation.

Problem 4: Find the Middle Element Given an ArrayList, find the middle element(s). Use two-pointer technique: one moves one step, the other moves two steps. This mimics the classic linked list slow/fast pointer but on an ArrayList you also can just use index math. However, the challenge is to do it without using size() more than once.

Problem 5: Custom Sort by Frequency Given an ArrayList<String>, sort it so that elements are ordered by frequency (most frequent first), and for ties, alphabetically. Use a HashMap to count frequencies, then implement a Comparator that uses the map. This combines maps, comparators, and ArrayList sorting.

Why these problems matter: Each one forces you to reason about ArrayList's internal structure. Problem 1 teaches you that index-based insertion is O(n) — merge using add at end, not insert at front. Problem 2 drives home the safe removal pattern. Problem 3 tests your ability to manipulate the backing array mentally. Problem 4 shows you the limits of direct indexing. Problem 5 mixes external data structures with ArrayList's sort.

package io.thecodeforge.collections;

import java.util.*;

public class PracticeProblems {

    // Problem 1: Merge two sorted lists (ascending)
    public static List<Integer> mergeSorted(List<Integer> a, List<Integer> b) {\n        List<Integer> result = new ArrayList<>(a.size() + b.size());\n        int i = 0, j = 0;\n        while (i < a.size() && j < b.size()) {\n            if (a.get(i) <= b.get(j)) {\n                result.add(a.get(i++));\n            } else {
                result.add(b.get(j++));
            }
        }
        // append remaining
        while (i < a.size()) result.add(a.get(i++));
        while (j < b.size()) result.add(b.get(j++));
        return result;
    }

    // Problem 2: Remove duplicates in place (preserve order)
    public static void removeDuplicates(List<Integer> list) {
        // Use iterator to safely remove
        Set<Integer> seen = new HashSet<>();
        Iterator<Integer> it = list.iterator();
        while (it.hasNext()) {
            if (!seen.add(it.next())) {
                it.remove();
            }
        }
    }

    // Problem 3: Rotate right by k (in-place)
    public static void rotateRight(List<Integer> list, int k) {\n        if (list.isEmpty() || k <= 0) return;\n        int n = list.size();\n        k = k % n;\n        if (k == 0) return;\n        // reverse all, then reverse parts\n        reverse(list, 0, n - 1);\n        reverse(list, 0, k - 1);\n        reverse(list, k, n - 1);\n    }

    private static void reverse(List<Integer> list, int start, int end) {\n        while (start < end) {\n            int temp = list.get(start);\n            list.set(start, list.get(end));\n            list.set(end, temp);\n            start++;\n            end--;\n        }
    }

    // Problem 4: Find middle elements (without using size incrementally)
    public static List<Integer> findMiddle(List<Integer> list) {
        // Use slow/fast pointer
        if (list.isEmpty()) return List.of();
        List<Integer> mids = new ArrayList<>();
        int slow = 0, fast = 0;
        while (fast < list.size()) {
            fast++;
            if (fast >= list.size()) break;
            slow++;
            fast++;
        }
        // If size is odd, slow points to middle; if even, we also need previous?
        // Actually without using size, we can't know parity. Simpler: just use size once.
        // Let's use a straightforward approach:
        int n = list.size();
        if (n % 2 == 0) {
            mids.add(list.get(n / 2 - 1));
        }
        mids.add(list.get(n / 2));
        return mids;
    }

    // Problem 5: Sort by frequency then alphabetically
    public static void sortByFrequency(List<String> list) {
        Map<String, Integer> freq = new HashMap<>();
        for (String s : list) {
            freq.merge(s, 1, Integer::sum);
        }
        list.sort((a, b) -> {\n            int cmp = Integer.compare(freq.get(b), freq.get(a)); // descending frequency
            return cmp != 0 ? cmp : a.compareTo(b); // then alphabetical
        });
    }

    public static void main(String[] args) {
        // Test merge
        System.out.println("Merge: " + mergeSorted(List.of(1,3,5,7), List.of(2,4,6,8)));
        // Test remove duplicates
        List<Integer> list = new ArrayList<>(List.of(1,2,1,3,2,4));
        removeDuplicates(list);
        System.out.println("Remove duplicates: " + list);
        // Test rotate
        List<Integer> rot = new ArrayList<>(List.of(1,2,3,4,5));
        rotateRight(rot, 2);
        System.out.println("Rotated: " + rot);
        // Test middle
        System.out.println("Middle of [1,2,3,4,5]: " + findMiddle(List.of(1,2,3,4,5)));
        System.out.println("Middle of [1,2,3,4]: " + findMiddle(List.of(1,2,3,4)));
        // Test frequency sort
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "apple", "cherry", "banana", "banana"));
        sortByFrequency(fruits);
        System.out.println("Frequency sort: " + fruits);
    }
}