4.4 ArrayList Fundamentals, Operations, and Array Comparison

4.4 ArrayList Fundamentals, Operations, and Array Comparison

[!NOTE] Exam Focus: Working with java.util.ArrayList is a core requirement of Oracle's "Arrays and ArrayLists" topic area. Candidates are tested on import requirements, generic type arguments and the diamond operator (<>), primitive wrapper classes and autoboxing/unboxing hazards, core manipulation methods (add, get, set, remove, size, clear), the dangerous remove(int) vs. remove(Object) overloaded method trap in integer lists, and the structural differences between standard arrays and ArrayLists.

While primitive arrays provide ultra-fast, cache-friendly storage for fixed-size sequences, real-world software frequently deals with data sets whose volume cannot be known in advance. When an application reads user input, processes database query results, or tracks items in an e-commerce shopping cart, the collection must grow and shrink dynamically. For these scenarios, Java provides the java.util.ArrayList class.

---

1. What Is ArrayList & How Does It Work?

An ArrayList is a resizable array implementation belonging to the Java Collections Framework that implements the java.util.List interface. Under the hood, an ArrayList encapsulates a standard Java array (an Object[] buffer named elementData):

1. Dynamic Growth: When an ArrayList is instantiated with its default constructor (new ArrayList<>()), it starts with an initial capacity (typically 10 elements in Java SE 8).
2. Automatic Buffer Reallocation: As elements are added and the internal array becomes full, the ArrayList automatically creates a new, larger array behind the scenes (typically $1.5\times$ the previous capacity), copies all existing elements into the new buffer, and discards the old array for garbage collection.
3. High-Level API: Unlike arrays that require manual index bookkeeping, ArrayList exposes intuitive methods to append, insert, replace, search, and delete elements.

Package Import Requirements

Unlike foundational classes such as String, System, and Math—which reside in java.lang and are imported automatically—ArrayList belongs to the java.util package. You must include an import statement at the top of your source file:

import java.util.ArrayList; // Single-class import
// OR
import java.util.*;          // Wildcard package import

Omitting the import statement causes a compilation error: cannot find symbol: class ArrayList.

---

2. Generics, Type Safety, and the Diamond Operator

Before Java 5, collections stored raw Object references. Programmers had to write error-prone manual casts whenever retrieving items:

// Legacy Pre-Java 5 Raw Type (Avoid in modern Java!)
ArrayList list = new ArrayList();
list.add("Hello");
list.add(42); // Any object allowed
String s = (String) list.get(0); // Requires explicit cast; runtime ClassCastException risk

Generics Syntax

Java 5 introduced Generics, allowing developers to specify the exact element type allowed in a collection using angle brackets (<Type>):

ArrayList<String> names = new ArrayList<String>();
names.add("Alice");
// names.add(100); // COMPILE ERROR: incompatible types: int cannot be converted to String
String first = names.get(0); // No cast required! Fully type-safe at compile time.

The Diamond Operator (<>)

Starting in Java 7 and continuing in Java SE 8, the compiler supports type inference for generic instance creation via the diamond operator (<>). Because the compiler already knows the element type from the variable declaration on the left-hand side, you can omit the type parameter on the right-hand side:

ArrayList<String> names = new ArrayList<>(); // Clean, idiomatic Java SE 8 syntax

---

3. The Object-Only Rule & Primitive Wrapper Classes

A critical rule governing Java collections is:

[!IMPORTANT] The Reference-Only Rule: Generic type arguments can only be reference types (objects). You can never specify a primitive data type as a generic parameter.

ArrayList<int> numbers = new ArrayList<int>();       // COMPILE ERROR!
ArrayList<double> prices = new ArrayList<double>(); // COMPILE ERROR!
ArrayList<boolean> flags = new ArrayList<boolean>(); // COMPILE ERROR!

Attempting to compile any of the above lines triggers a compilation error: unexpected type: found int, required: reference.

To store numbers, characters, or boolean values inside an ArrayList, you must use Java's Primitive Wrapper Classes located in java.lang:

[!WARNING] Spelling Trap on Exam 1Z0-811: Pay strict attention to the spelling of the wrapper classes. While six wrappers simply capitalize the primitive name, two are fully spelled out:

• int wraps to Integer (NOT Int)
• char wraps to Character (NOT Char)

Writing ArrayList<Int> or ArrayList<Char> causes a compilation error because no classes named Int or Char exist in the standard Java library!

All eight primitive wrapper classes are immutable. Once an Integer object is created with value 42, its internal state can never be modified.

---

4. Autoboxing, Unboxing, and the NullPointerException Trap

Converting between primitives and wrapper objects is automated by the Java compiler:

• Autoboxing: Automatic conversion from a primitive type to its wrapper object (e.g., Integer boxed = 10; becomes Integer.valueOf(10)).
• Unboxing: Automatic conversion from a wrapper object back to its primitive value (e.g., int val = boxed; becomes boxed.intValue()).

ArrayList<Integer> scores = new ArrayList<>();
scores.add(95);          // Autoboxing: compiler wraps 95 into Integer.valueOf(95)
int top = scores.get(0); // Unboxing: compiler calls scores.get(0).intValue()

The NullPointerException Unboxing Trap

Because wrapper variables are object references, they can hold null. A primitive variable, however, can never hold null.

When Java attempts to unbox a wrapper reference that happens to be null, a runtime NullPointerException occurs:

Integer count = null; // Legal: object reference assigned null
int total = count;    // Compiles cleanly, BUT throws NullPointerException at runtime!

The compiler translates int total = count; into int total = count.intValue();. Invoking .intValue() on a null reference causes an immediate crash. The exact same trap occurs when an ArrayList stores a null entry:

ArrayList<Double> rates = new ArrayList<>();
rates.add(null);        // Legal: ArrayList stores references
double r = rates.get(0); // Throws NullPointerException during unboxing!

---

5. Core ArrayList Manipulation Methods

The 1Z0-811 exam evaluates candidate mastery of the following core ArrayList methods:

Adding Elements: add(E e) and add(int index, E e)

1. boolean add(E element): Appends the specified element to the end of the list. Always returns true.
2. void add(int index, E element): Inserts the element at the specified zero-based index. Elements at and above that position are shifted one position to the right. Returns void.

ArrayList<String> letters = new ArrayList<>();
letters.add("A");    // [A] - appends to end
letters.add("C");    // [A, C] - appends to end
letters.add(1, "B"); // [A, B, C] - inserts at index 1; shifts 'C' right

Accessing & Replacing Elements: get(int index) and set(int index, E e)

Unlike arrays that use brackets (arr[i]), ArrayList uses method calls:

1. E get(int index): Returns the element at the specified index without modifying the list.
2. E set(int index, E element): Replaces the element at the specified index. Crucial detail: set() returns the element that was replaced (the old value), and does not change the size() of the list!

ArrayList<String> colors = new ArrayList<>();
colors.add("Red");
colors.add("Blue");

String old = colors.set(1, "Green"); // Replaces "Blue" with "Green"
System.out.println(old);             // Prints: Blue (the replaced element!)
System.out.println(colors.get(1));   // Prints: Green
System.out.println(colors.size());   // Prints: 2 (size unchanged)

[!CAUTION] The set() Boundary Trap: You cannot use set() to append elements or grow an ArrayList! Calling colors.set(colors.size(), "Yellow") throws an IndexOutOfBoundsException. To add a new element, you must call add(), not set().

Checking Size & State: size(), isEmpty(), and clear()

1. int size(): Returns the number of elements currently stored in the list. Remember: size() is a method with parentheses, unlike array length which is a field!
2. boolean isEmpty(): Returns true if size() == 0, otherwise false.
3. void clear(): Removes all elements from the list, resetting size() to 0.

Searching Elements: contains(Object o) and indexOf(Object o)

1. boolean contains(Object o): Returns true if the list contains an element matching the argument (evaluated via .equals()).
2. int indexOf(Object o): Returns the 0-based index of the first occurrence, or -1 if not found.

---

6. The Overloaded remove() Method Trap in ArrayList<Integer>

ArrayList defines two heavily tested overloaded remove methods:

1. E remove(int index): Removes the element at the specified index, shifts subsequent elements left, and returns the removed element.
2. boolean remove(Object o): Removes the first occurrence of the specified object (matching via .equals()), and returns true if an element was found and removed.

The Integer List Trap

Consider what happens when working with an ArrayList<Integer>:

ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(10); // Index 0
numbers.add(20); // Index 1
numbers.add(30); // Index 2

numbers.remove(1); // WHICH METHOD OVERLOAD EXECUTES?

[!WARNING] Primitive Match Rule: Because the literal 1 is a primitive int, the compiler selects the exact primitive parameter match: remove(int index), NOT remove(Object o)!

Therefore, numbers.remove(1) removes the element at index 1 (which is 20), NOT the number 1! After execution, numbers contains [10, 30].

To remove the integer value 1 as an object, you must explicitly pass an Integer object reference or cast to Object:

numbers.remove(Integer.valueOf(1)); // Calls remove(Object): searches for value 1
numbers.remove((Object) 1);         // Calls remove(Object): searches for value 1

---

7. Boundary Safety: IndexOutOfBoundsException

Accessing an invalid index in an ArrayList throws an unchecked java.lang.IndexOutOfBoundsException (the superclass of ArrayIndexOutOfBoundsException).

Notice the difference in valid index boundaries across methods:

For add(index, elem), index == size() is completely legal—it simply appends the element to the end of the list.

---

8. Architectural Comparison: Array vs. ArrayList

The 1Z0-811 examination frequently tests candidate ability to contrast standard Java arrays with ArrayList. The following table summarizes every key architectural dimension: