Wrapper Classes & Autoboxing New in 2026

Wrapper classes bridge the gap between Java's primitive types and its object-oriented type system. Understanding them is essential for using ArrayList correctly and is explicitly tested in the 2025-2026 AP CSA curriculum.

The Three Exam-Relevant Wrapper Classes

Why Wrapper Classes Exist

Java generics only work with reference types. Primitives (int, double, boolean) are NOT reference types — they live on the stack, not the heap. Wrapper classes are the reference-type version of each primitive.

Autoboxing: Primitive to Wrapper

Java automatically wraps a primitive in its wrapper class when a reference type is expected. You don't have to write new Integer(5) — Java does it for you.

Unboxing: Wrapper to Primitive

Unboxing is the reverse: Java automatically extracts the primitive value from a wrapper object.

Integer x = 100;   // autoboxing
int y = x;         // unboxing: y = 100
int z = x + 5;     // unboxing happens automatically in arithmetic

Integer.parseInt and Double.parseDouble

These static methods convert a String to a primitive. They are commonly used when reading numeric data from files with Scanner.

String s = "123";
int n = Integer.parseInt(s);            // n = 123
double d = Double.parseDouble("3.14");  // d = 3.14

// Reading a number from a line of file input
String line = sc.nextLine();
int value = Integer.parseInt(line.trim());

Integer.MIN_VALUE and Integer.MAX_VALUE

These constants represent the extreme values of an int. They are useful as starting values in max/min accumulator patterns.

int largest = Integer.MIN_VALUE;  // start below any real value
for (int v : arr)
{
    if (v > largest)
        largest = v;
}

== vs .equals() with Wrapper Objects

This is the most common exam trap for wrapper classes. == compares references; .equals() compares values. Java caches Integer objects from -128 to 127, so == may return true for small values but false for larger ones — an inconsistent behavior you must never rely on.

Integer a = 127;
Integer b = 127;
System.out.println(a == b);       // true  (cached)
System.out.println(a.equals(b));  // true

Integer c = 200;
Integer d = 200;
System.out.println(c == d);       // false (not cached - new objects)
System.out.println(c.equals(d));  // true

Wrapper Classes in ArrayList Operations

Practice MCQs

These questions follow AP exam difficulty: predict the answer before reading the choices, watch for spot-the-error and multi-correct (I/II/III) formats, and notice that variable names give away nothing about what the code does.

Integer p = 200;
Integer q = 200;
System.out.println(p == q);
System.out.println(p.equals(q));

I.   double d = Double.parseDouble("3.14");
II.  int n = Integer.parseInt("twelve");
III. int k = Integer.parseInt("42 ");

Common Mistakes

• Using int in an ArrayList generic: Must be Integer, not int.
• Using == to compare Integer objects: Always use .equals().
• Unboxing null: If a list element is null, assigning it to an int throws NullPointerException.
• Initializing min with 0 instead of Integer.MAX_VALUE: If all data values are positive, a min accumulator starting at 0 never updates.
• Forgetting that Integer.parseInt rejects whitespace: Trim the string first if it may have leading or trailing spaces.

Related Topics