In the world of Java, we frequently encounter the limitation of standard arrays: their size is immutable. Once an array is instantiated, its capacity is locked into memory. This poses a significant challenge when handling data streams of unknown or varying lengths, such as a list of students joining a club or scores being added to a game session. To address this, the Java Collections Framework provides the `ArrayList` class, located in the `java.util` package. An `ArrayList` is a dynamic data structure that manages an underlying array, automatically resizing itself as elements are added or removed. This abstraction allows programmers to focus on data management rather than memory reallocation logic. A defining characteristic of the `ArrayList` is that it can only store objects, not primitive types. This is where the concept of Wrapper Classes becomes essential for the AP CSA exam. While you might want to store a list of integers, you cannot declare an `ArrayList`. Instead, you must use the `Integer` wrapper class: `ArrayList`. Java facilitates this through a process called autoboxing and unboxing. Autoboxing is the automatic conversion the Java compiler makes between the primitive types and their corresponding object wrapper classes (e.g., converting an `int` to an `Integer`). Unboxing is the reverse. When you add an `int` to an `ArrayList`, Java "boxes" it into an object. When you retrieve it, Java "unboxes" it back into a primitive. This seamless transition is convenient but hides the fact that objects occupy more memory and have different equality behaviors than primitives. When declaring an `ArrayList`, we use generics, indicated by the angle brackets ``. The syntax `ArrayList list = new ArrayList();` tells the compiler that this specific list will only hold `String` references. On the AP exam, you will often see the "diamond operator" on the right side: `new ArrayList<>()`, which is perfectly valid as the compiler infers the type from the left-side declaration. Understanding that an `ArrayList` stores references, not actual values (except for the boxed primitives), is vital for understanding how memory is utilized in the heap. Worked Example 1: Consider the following declaration: `ArrayList weights = new ArrayList();`. If we execute `weights.add(65.5);`, what process occurs? Solution: The primitive `double` value $65.5$ is autoboxed into a `Double` object before being stored in the list. The list now holds a reference to that `Double` object in the heap. Worked Example 2: Evaluate the legality of this statement: `ArrayList scores = new ArrayList();` Solution: This is illegal. `ArrayList` cannot hold primitives. The correct declaration is `ArrayList scores = new ArrayList();`.