Wrapper classes

A list that won't take a number

What are wrapper classes?

Words you'll meet in this lesson

The eight wrappers

Five jobs a wrapper class does

Text to number: parseXxx vs valueOf

public class Main {
    public static void main(String[] args) {
        String fromForm = "250";

        int qty = Integer.parseInt(fromForm);        // primitive int
        Integer boxed = Integer.valueOf(fromForm);   // Integer object
        double price = Double.parseDouble("99.5");
        boolean agreed = Boolean.parseBoolean("TRUE"); // case-insensitive

        System.out.println(qty + 1);
        System.out.println(boxed);
        System.out.println(price * 2);
        System.out.println(agreed);
    }
}

If the text is not a valid number, parsing throws NumberFormatException, an unchecked exception (Lesson 9.3):

public class Main {
    public static void main(String[] args) {
        String[] inputs = {"42", "12a", ""};
        for (String s : inputs) {
            try {
                System.out.println("ok: " + Integer.parseInt(s));
            } catch (NumberFormatException e) {
                System.out.println("bad: " + e.getMessage());
            }
        }
    }
}

Limits, characters and handy utilities

public class Main {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);           // biggest int
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Byte.MAX_VALUE);

        System.out.println(Character.isDigit('7'));       // true
        System.out.println(Character.isLetter('#'));      // false
        System.out.println(Character.toUpperCase('r'));   // R

        System.out.println(Integer.toBinaryString(10));   // 1010
        System.out.println(Integer.toHexString(255));     // ff
        System.out.println(Integer.compare(5, 9));        // negative: 5 < 9
    }
}

Comparing wrappers: equals, not ==

public class Main {
    public static void main(String[] args) {
        Integer a = Integer.valueOf(127), b = Integer.valueOf(127);
        Integer c = Integer.valueOf(128), d = Integer.valueOf(128);

        System.out.println(a == b);        // same cached object
        System.out.println(c == d);        // two different objects!
        System.out.println(c.equals(d));   // compares the values
    }
}

What happens when you call Integer.valueOf

1. You ask for an Integer

   Integer seats = Integer.valueOf(120);

   valueOf is a static factory method of class Integer. It decides whether to reuse an object or create one.

2. Is the value between -128 and 127?

   The JDK has an inner class Integer.IntegerCache holding an array of 256 ready-made Integer objects, created when the cache class is first initialised. For 120, valueOf returns the object at that slot. No new object is created.

3. Outside the range: a new object

   Integer fare = Integer.valueOf(500);   // new Integer object on the heap

   For 500, valueOf creates a fresh object on the heap. Ask again for 500 and you get another fresh object. That's why == is unreliable.

4. The variable holds a reference

   seats is a reference on the stack (like any object variable, Lesson 2.3). The value 120 lives inside the object on the heap, in a private final int value field.

5. Getting the number back

   int n = fare.intValue();   // unboxing: copies 500 out of the object

   intValue() reads the private value field and returns a plain int. The object is unchanged: wrappers are immutable, so “changing” a wrapper variable always means pointing it to a different object.

Cached and new Integer objects: both views

Left: the code and what it prints. Right: the stack and heap, with the JDK's cache of ready-made Integer objects.

Wrapper classes in real systems

Almost every program that reads input, stores data in collections or talks to a database uses wrapper classes, often without you noticing.

Watch it with an example: a train booking form

A booking page sends everything as text. Watch the server turn the passenger count into a number, and refuse text that isn't one.

Examples are simplified. Real systems add more checks, such as ranges, trimming spaces and logging rejected input.

A billing counter that reads text input safely

import java.util.ArrayList;

public class Main {
    static Integer readQty(String text) {
        try {
            return Integer.valueOf(text.trim());
        } catch (NumberFormatException e) {
            return null;                       // null means "invalid"
        }
    }

    public static void main(String[] args) {
        String[] typed = {"2", " 5 ", "two", "1"};
        ArrayList<Integer> qtys = new ArrayList<>();

        for (String t : typed) {
            Integer q = readQty(t);
            if (q == null) {
                System.out.println("Skipped: '" + t + "'");
            } else {
                qtys.add(q);
            }
        }
        int total = 0;
        for (Integer q : qtys) {
            total += q.intValue();
        }
        System.out.println("Quantities: " + qtys);
        System.out.println("Total items: " + total);
    }
}

• Integer.valueOf(text.trim())Removes spaces, then parses the text into an Integer object.
• return null;Only possible because the return type is Integer, not int. Null signals “bad input”.
• ArrayList<Integer>A list must hold objects, so we store Integer, not int.
• q.intValue()Unboxes the object to a plain int for the arithmetic.

Watch the cache on the heap

This trace is recorded from the real JVM. Watch which valueOf calls create a new object (a new # number on the heap) and which hand back one that already exists.

Worked examples: real problems, solved and traced in memory

Three everyday tasks where wrapper classes do the heavy lifting: reading text, validating characters, and using null for “missing”.

"Riya,85,92,78"

Riya: 85.0

"410210", "41021A", "012345"

true
false
false

{2, null, 3, null, 1}

Total overtime: 6 h
Days not entered: 2

Check yourself

Quick revision

Interview and viva questions

Practice problems

Parse text safely, use the wrapper helpers, and avoid the == trap. The last three are business tasks.

"45", "55"

4555
100

public class Main {
    public static void main(String[] args) {
        String a = "45", b = "55";
        System.out.println(a + b);
        int sum = Integer.parseInt(a) + Integer.parseInt(b);
        System.out.println(sum);
    }
}

(none)

int:  -2147483648 to 2147483647
long: -9223372036854775808 to 9223372036854775807

public class Main {
    public static void main(String[] args) {
        System.out.println("int:  " + Integer.MIN_VALUE + " to " + Integer.MAX_VALUE);
        System.out.println("long: " + Long.MIN_VALUE + " to " + Long.MAX_VALUE);
    }
}

"+91 98765-43210"

Digits: 12

public class Main {
    public static void main(String[] args) {
        String phone = "+91 98765-43210";
        int digits = 0;
        for (char c : phone.toCharArray()) {
            if (Character.isDigit(c)) {
                digits++;
            }
        }
        System.out.println("Digits: " + digits);
    }
}

Integer s1 = 250, s2 = 250

with == : false
equals  : true

public class Main {
    public static void main(String[] args) {
        Integer s1 = Integer.valueOf(250);
        Integer s2 = Integer.valueOf(250);
        System.out.println("with == : " + (s1 == s2));
        System.out.println("equals  : " + s1.equals(s2));
    }
}

45

101101
55
2d
45

public class Main {
    public static void main(String[] args) {
        int n = 45;
        System.out.println(Integer.toBinaryString(n));
        System.out.println(Integer.toOctalString(n));
        System.out.println(Integer.toHexString(n));
        System.out.println(Integer.parseInt("2d", 16));
    }
}

{"499.00", "1299.50", "bad", "75"}

Total: 1873.5
Rejected: 1

public class Main {
    public static void main(String[] args) {
        String[] prices = {"499.00", "1299.50", "bad", "75"};
        double total = 0;
        int rejected = 0;
        for (String p : prices) {
            try {
                total += Double.parseDouble(p);
            } catch (NumberFormatException e) {
                rejected++;
            }
        }
        System.out.println("Total: " + total);
        System.out.println("Rejected: " + rejected);
    }
}

"Riya@2026", "riya2026"

Riya@2026 -> true
riya2026  -> false

public class Main {
    static boolean strong(String pw) {
        boolean upper = false, digit = false, symbol = false;
        for (char c : pw.toCharArray()) {
            if (Character.isUpperCase(c)) upper = true;
            else if (Character.isDigit(c)) digit = true;
            else if (!Character.isLetter(c)) symbol = true;
        }
        return pw.length() >= 8 && upper && digit && symbol;
    }

    public static void main(String[] args) {
        System.out.println("Riya@2026 -> " + strong("Riya@2026"));
        System.out.println("riya2026  -> " + strong("riya2026"));
    }
}

{"maxUsers=250", "debug=true", "timeout=abc"}

maxUsers=250, debug=true, timeout=30

public class Main {
    static int intOr(String text, int fallback) {
        try {
            return Integer.parseInt(text);
        } catch (NumberFormatException e) {
            return fallback;
        }
    }

    public static void main(String[] args) {
        String[] lines = {"maxUsers=250", "debug=true", "timeout=abc"};
        int maxUsers = intOr(lines[0].split("=")[1], 100);
        boolean debug = Boolean.parseBoolean(lines[1].split("=")[1]);
        int timeout = intOr(lines[2].split("=")[1], 30);
        System.out.println("maxUsers=" + maxUsers + ", debug=" + debug + ", timeout=" + timeout);
    }
}

Real-world scenario questions (asked in company interviews)

Wrapper questions in interviews usually hide inside bugs: a comparison that “randomly” fails, a crash on empty input, a zero that should have been “missing”.