Array vs ArrayList Trade-offs

## What these two things are **An array** is the most basic ordered container built into the Java language itself (not a library class). You create it with a fixed length: ```java int[] numbers = new int[5]; // 5 slots, indexes 0..4 ``` The number `5` is the *capacity and the size at the same time* — an array has exactly that many slots forever. You cannot add a sixth element; you'd have to create a new, bigger array and copy everything over yourself. Arrays can hold **primitives** (`int`, `double`, `boolean`, `char`, …) directly, or they can hold **object references** (`String[]`, `Person[]`). An array gives you only two things: `arr.length` (a field, no parentheses) to ask how many slots it has, and `arr[i]` to read or write slot `i`. **An ArrayList** is a class from the standard library (`java.util.ArrayList`). It is a **resizable list**: you can keep calling `add()` and it grows as needed, and `remove()` makes it smaller. Internally an ArrayList *is itself backed by an array* — when that internal array fills up, ArrayList quietly allocates a bigger one (typically about 1.5x the old size) and copies the elements across. You never see this; from your side it just "grows." An ArrayList exposes a whole API: `size()`, `add()`, `get(i)`, `set(i, value)`, `remove()`, `contains()`, `isEmpty()`, iteration with a for-each loop, and so on. ## The key word: generics and boxing ArrayList is **generic**: you write `ArrayList<String>` or `ArrayList<Integer>`. The `<...>` part is a type parameter that says what kind of element it holds, and the compiler checks it. Generics only work with **reference types** (objects), not primitives. So you *cannot* write `ArrayList<int>`. To store numbers you use `ArrayList<Integer>`, where `Integer` is the **wrapper class** for the primitive `int`. Converting an `int` to an `Integer` object is called **autoboxing** (and back is **unboxing**). It happens automatically: ```java List<Integer> list = new ArrayList<>(); list.add(7); // autoboxing: int 7 -> Integer object int x = list.get(0); // unboxing: Integer -> int ``` Each boxed `Integer` is a separate object on the heap with its own object header, so a million boxed ints take far more memory than `int[1_000_000]`, and boxing/unboxing costs CPU. A raw `int[]` stores the numbers packed tightly with no per-element object overhead. ## When to choose which Use a **raw array** when: - The size is fixed and known up front (e.g., the 12 months of the year). - You are storing **primitives** and care about memory or speed — `int[]` avoids the boxing tax. - You are in low-level / performance-critical code, or interoperating with APIs that take arrays (varargs, `String.split`, `byte[]` for I/O). Use an **ArrayList** when: - The number of elements is unknown or changes over time. - You want the convenience of the Collections API (search, iteration, removal, passing as `List`). - You are writing ordinary business logic — this is the **default** in modern Java. ## A rule of thumb Reach for `ArrayList` (typed as `List`) by default. Drop to a raw array only when you have a concrete reason: fixed size, primitive performance, or an API that demands one. The cost of an array is manual size management and weaker safety; the cost of ArrayList is boxing for primitives plus a small per-object overhead.