4.7 Wrapper Classes

1. Integer and Double objects

Each primitive type has a matching wrapper class whose objects hold one value of that type. For the AP® exam you need two: Integer (wraps an int) and Double (wraps a double). Both are part of the java.lang package 4.7.A.1, like String and Math, so no import is needed.

Integer objects are immutable: once an Integer object is created, its attributes cannot be changed 4.7.A.1. Double objects are immutable in the same way 4.7.A.1. There is no method like setValue.

Primitive type	Wrapper class	Example value
int	Integer	42
double	Double	3.75

Why bother? Some Java code only works with objects. The most important example is ArrayList (topic 4.8), which stores object references. A list of whole numbers must use Integer:

ArrayList<int> laps = new ArrayList<int>();

Compiler error:

error: unexpected type

2. Autoboxing

Autoboxing is the automatic conversion the Java compiler makes from a primitive type to its wrapper class: an int to an Integer, a double to a Double 4.7.A.2. The compiler applies it when a primitive value is assigned to a variable of the wrapper class, or passed as a parameter to a method that expects an object of that wrapper class 4.7.A.2.

public static void showBoxed(Integer box)
{
    System.out.println("Received the object " + box);
}

Integer goals = 3;          // assigned to an Integer variable: autoboxing
Double price = 4.99;        // assigned to a Double variable: autoboxing

int bonus = 7;
showBoxed(bonus);           // passed to an Integer parameter: autoboxing

System.out.println(goals + " " + price);

Output:

Received the object 7
3 4.99

The match must be exact in type: a double value cannot be boxed into an Integer.

Integer wrong = 4.5;

Compiler error:

error: incompatible types: double cannot be converted to Integer

3. Unboxing

Unboxing is the automatic conversion the Java compiler makes from a wrapper class to its primitive type: an Integer to an int, a Double to a double 4.7.A.3. The compiler applies it when a wrapper object is assigned to a variable of the primitive type, or passed as a parameter to a method that expects that primitive type 4.7.A.3.

public static double half(double value)
{
    return value / 2;
}

Integer stored = 25;
Double rate = 0.5;

int plain = stored;                   // assigned to an int variable: unboxing
System.out.println(plain + 5);

System.out.println(half(rate));       // passed to a double parameter: unboxing
System.out.println(stored * rate);    // arithmetic unboxes both

Output:

30
0.25
12.5

Watch out: a wrapper variable is a reference, so it can be null. Unboxing null fails at run time.

Integer missing = null;
int value = missing;
System.out.println(value);

Output:

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "java.lang.Integer.intValue()" because "missing" is null

The program stops with a NullPointerException. (The exact wording after the colon depends on your Java version and settings; on the AP® exam you only need the exception name.)

4. Immutable in practice

Because Integer objects cannot change, code that looks like it changes one actually creates a new object. The variable gets a reference to the new object, and any other variable still refers to the old one.

Integer score = 10;
Integer saved = score;      // both refer to the same Integer object

score++;                    // unbox 10, add 1, box 11 into a NEW object

System.out.println(score);
System.out.println(saved);

Output:

11
10

Watch out: == on two wrapper objects compares references, not values. Compare with equals, or unbox to int first.

Integer a = 1000;
Integer b = 1000;
int x = a;                  // unboxing
int y = b;                  // unboxing
System.out.println(a.equals(b));
System.out.println(x == y);
System.out.println(a == b);

Output:

true
true
false

(The == result for small values such as 5 can be true, because Java reuses some small Integer objects. Never rely on it.)

5. parseInt and parseDouble

Data read from a file or split from a line arrives as String values. Two static methods in the Java Quick Reference convert them to numbers:

• static int parseInt(String s) in Integer returns the String argument as an int 4.7.A.4.
• static double parseDouble(String s) in Double returns the String argument as a double 4.7.A.5.

String line = "Ana,12,8.5";
String[] parts = line.split(",");

int points = Integer.parseInt(parts[1]);
double minutes = Double.parseDouble(parts[2]);

System.out.println(parts[1] + parts[1]);     // String + String: joins
System.out.println(points + points);         // int + int: adds
System.out.println(points / minutes);

Output:

1212
24
1.411764705882353

Watch out: the String must really look like a number of that type, or the program stops with a NumberFormatException.

System.out.println(Double.parseDouble("12"));
System.out.println(Integer.parseInt("12.0"));

Output:

12.0
Exception in thread "main" java.lang.NumberFormatException: For input string: "12.0"

parseDouble("12") works (a whole number is a valid double), but parseInt("12.0") fails.