☕ Java

Java Wrapper Classes — Autoboxing, Unboxing, Methods & Best Practices

Everything you need to know about Java Wrapper Classes — what they are, why they exist, autoboxing and unboxing, Integer cache trap, parsing and conversion methods, usage in Collections and Generics, performance pitfalls, and real-world production code examples.

📅

Last Updated

March 2026

⏱️

Read Time

22 min

🎯

Level

Beginner to Intermediate

🏷️

Chapter

20 of 35

What are Wrapper Classes in Java?

In Java, primitive types — int, double, boolean, char, byte, short, long, float — are not objects. They are raw values stored directly in memory for maximum performance. However, Java's object-oriented ecosystem — including Collections, Generics, and many APIs — requires objects, not primitives. Wrapper classes solve this: each primitive type has a corresponding class in java.lang that wraps the primitive value in an object.

Wrapper classes serve three main purposes: (1) Allow primitives to be used as objects — e.g., storing int values in a List<Integer>. (2) Provide utility methods for parsing, converting, and comparing values — e.g., Integer.parseInt(), Double.isNaN(). (3) Allow primitives to represent the null state — useful when absence of a value must be distinguished from zero or false. All wrapper classes are in the java.lang package (auto-imported), are immutable, and are declared final (cannot be subclassed).

Primitive vs Wrapper — Side-by-Side Comparison

Understanding when to use a primitive and when to use its wrapper class is fundamental to writing correct, performant Java. The table below summarizes all key differences.

Aspect	Primitive (e.g. int)	Wrapper Class (e.g. Integer)
Storage	Stack (direct value)	Heap (object reference)
Null allowed	❌ No — default is 0/false/\u0000	✅ Yes — can be null
Performance	✅ Fastest — no object overhead	⚠️ Slower — heap allocation, GC pressure
Use in Collections	❌ List<int> is invalid	✅ List<Integer> works fine
Use in Generics	❌ Not allowed as type parameter	✅ Fully supported
Utility methods	❌ None	✅ parseInt, valueOf, compareTo, etc.
Memory	4 bytes for int	~16 bytes for Integer object
Default (field)	0, false, \u0000	null
Comparison	== is value comparison (correct)	== compares references — use .equals()
Serialization	Serializable by nature	Implements Serializable

Autoboxing & Unboxing — Java's Automatic Conversion

Autoboxing is the automatic conversion of a primitive to its corresponding wrapper class, performed by the Java compiler. Unboxing is the reverse — automatic conversion from a wrapper object back to a primitive. Introduced in Java 5, these conversions happen transparently wherever a primitive is used where an object is expected, or vice versa. Under the hood, the compiler inserts calls to Integer.valueOf() for boxing and intValue() for unboxing.

☕ JavaAutoboxingUnboxing.java

import java.util.*;

public class AutoboxingUnboxing {
    public static void main(String[] args) {

        // ── AUTOBOXING — primitive → wrapper ────────────────────────────
        int primitiveInt = 42;
        Integer wrappedInt = primitiveInt;  // Autoboxing
        // Compiler translates to: Integer wrappedInt = Integer.valueOf(42);

        double primitiveDouble = 3.14;
        Double wrappedDouble = primitiveDouble;  // Autoboxing

        boolean primitiveBool = true;
        Boolean wrappedBool = primitiveBool;  // Autoboxing

        // ── UNBOXING — wrapper → primitive ───────────────────────────────
        Integer boxed = Integer.valueOf(100);
        int unboxed = boxed;  // Unboxing
        // Compiler translates to: int unboxed = boxed.intValue();

        // ── Autoboxing in Collections ────────────────────────────────────
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);   // Autoboxing: int 1 → Integer.valueOf(1)
        numbers.add(2);
        numbers.add(3);

        int first = numbers.get(0);  // Unboxing: Integer → int
        System.out.println("First: " + first);  // 1

        // ── Autoboxing in arithmetic ─────────────────────────────────────
        Integer a = 10;
        Integer b = 20;
        int sum = a + b;  // Both unboxed to int, then added
        System.out.println("Sum: " + sum);  // 30

        // ── Autoboxing in method calls ───────────────────────────────────
        printValue(99);  // int autoboxed to Integer for method param

        // ❌ DANGER: Unboxing null wrapper → NullPointerException
        Integer nullInt = null;
        // int x = nullInt;  // NPE! nullInt.intValue() on null
        // Fix: null check before unboxing
        if (nullInt != null) {
            int x = nullInt;
        }
    }

    static void printValue(Integer val) {
        System.out.println("Value: " + val);
    }
}

Integer Class — Methods & Usage

Integer is the most commonly used wrapper class. It wraps the primitive int and provides a rich set of static and instance methods for parsing, converting, comparing, and performing bitwise operations on integer values.

📌

Creating Integer Objects

Integer.valueOf(int) — preferred factory method; uses cache for -128 to 127. Integer.valueOf(String) — parses string to Integer object. new Integer(int) — deprecated since Java 9; use valueOf() instead. Autoboxing: Integer i = 42; — compiler calls Integer.valueOf(42) automatically.

🔑

Parsing & Converting

Integer.parseInt(String) — parses String to primitive int. Throws NumberFormatException if invalid. Integer.parseInt(String, radix) — parse in given base (2 for binary, 16 for hex). Integer.toString(int) — int to String. Integer.toBinaryString(int) — decimal to binary string. Integer.toHexString(int) — decimal to hex string. Integer.toOctalString(int) — decimal to octal string.

🔄

Comparison & Math Utilities

Integer.compare(x, y) — compare two ints; returns negative/0/positive. Integer.max(a, b) — larger of two ints. Integer.min(a, b) — smaller of two ints. Integer.sum(a, b) — sum (useful as method reference). Integer.MAX_VALUE — 2147483647. Integer.MIN_VALUE — -2147483648. intValue() — extract primitive int from Integer object. compareTo(Integer) — instance comparison.

☕ JavaIntegerClass.java

public class IntegerClass {
    public static void main(String[] args) {

        // ── Creating Integer ─────────────────────────────────────────────
        Integer a = Integer.valueOf(100);     // Preferred — uses cache
        Integer b = Integer.valueOf("200");   // Parse string → Integer
        Integer c = 300;                      // Autoboxing

        // ── Parsing String to int ────────────────────────────────────────
        int parsed = Integer.parseInt("42");
        System.out.println(parsed + 8);      // 50

        int hex = Integer.parseInt("1F", 16); // Parse hex string
        System.out.println(hex);             // 31

        int bin = Integer.parseInt("1010", 2); // Parse binary string
        System.out.println(bin);             // 10

        // ── Converting int to other representations ──────────────────────
        System.out.println(Integer.toBinaryString(10));  // 1010
        System.out.println(Integer.toHexString(255));    // ff
        System.out.println(Integer.toOctalString(8));    // 10
        System.out.println(Integer.toString(42));        // "42"

        // ── Constants ────────────────────────────────────────────────────
        System.out.println(Integer.MAX_VALUE);  // 2147483647
        System.out.println(Integer.MIN_VALUE);  // -2147483648
        System.out.println(Integer.SIZE);       // 32 (bits)
        System.out.println(Integer.BYTES);      // 4 (bytes)

        // ── Comparison & Math ────────────────────────────────────────────
        System.out.println(Integer.compare(10, 20));   // negative
        System.out.println(Integer.max(10, 20));       // 20
        System.out.println(Integer.min(10, 20));       // 10
        System.out.println(Integer.sum(10, 20));       // 30

        // ── Extracting primitive value ───────────────────────────────────
        Integer wrapped = Integer.valueOf(55);
        int primitive = wrapped.intValue();   // Explicit unboxing
        long asLong   = wrapped.longValue();  // Widening via wrapper
        double asDouble = wrapped.doubleValue();

        // ── Bit operations (Java 8+) ─────────────────────────────────────
        System.out.println(Integer.bitCount(7));        // 3 (bits set in 0111)
        System.out.println(Integer.highestOneBit(10));  // 8
        System.out.println(Integer.reverse(1));         // reversed bits
        System.out.println(Integer.numberOfLeadingZeros(1));  // 31

        // ── parseInt with error handling ─────────────────────────────────
        try {
            int invalid = Integer.parseInt("abc"); // NumberFormatException
        } catch (NumberFormatException e) {
            System.out.println("Invalid number: " + e.getMessage());
        }
    }
}

Double & Float Class — Floating-Point Wrappers

Double and Float are wrapper classes for double and float primitives respectively. They include essential utility methods for parsing decimal strings, checking for special floating-point values like NaN (Not a Number) and Infinity, and performing comparisons. Double is the more commonly used of the two, as double is preferred over float in modern Java for its precision.

☕ JavaDoubleFloatClass.java

public class DoubleFloatClass {
    public static void main(String[] args) {

        // ── Creating Double ──────────────────────────────────────────────
        Double d1 = Double.valueOf(3.14);
        Double d2 = Double.valueOf("2.718");  // Parse string → Double
        Double d3 = 1.618;                    // Autoboxing

        // ── Parsing ──────────────────────────────────────────────────────
        double parsed = Double.parseDouble("3.14159");
        System.out.println(parsed);  // 3.14159

        float parsedFloat = Float.parseFloat("2.71");
        System.out.println(parsedFloat);  // 2.71

        // ── Special values ───────────────────────────────────────────────
        System.out.println(Double.MAX_VALUE);   // 1.7976931348623157E308
        System.out.println(Double.MIN_VALUE);   // 5.0E-324 (smallest positive)
        System.out.println(Double.NaN);         // NaN
        System.out.println(Double.POSITIVE_INFINITY); // Infinity
        System.out.println(Double.NEGATIVE_INFINITY); // -Infinity

        // ── Checking special floating-point states ───────────────────────
        double result = 10.0 / 0.0;
        System.out.println(Double.isInfinite(result));  // true
        System.out.println(Double.isNaN(Double.NaN));   // true

        double nan = 0.0 / 0.0;
        // ❌ NaN != NaN in Java — use isNaN() to check
        System.out.println(nan == Double.NaN);           // false!
        System.out.println(Double.isNaN(nan));           // true ✅

        // ── Comparison ───────────────────────────────────────────────────
        System.out.println(Double.compare(3.14, 2.71));  // positive
        System.out.println(Double.max(3.14, 2.71));      // 3.14
        System.out.println(Double.min(3.14, 2.71));      // 2.71
        System.out.println(Double.sum(1.5, 2.5));        // 4.0

        // ── Extracting primitive ─────────────────────────────────────────
        Double wrapped = Double.valueOf(9.81);
        double primitive = wrapped.doubleValue();
        int asInt = wrapped.intValue();   // Truncates decimal: 9
        System.out.println(asInt);        // 9

        // ── float vs double precision ────────────────────────────────────
        float f = 1.0f / 3.0f;
        double dbl = 1.0 / 3.0;
        System.out.println(f);    // 0.33333334 (less precise)
        System.out.println(dbl);  // 0.3333333333333333 (more precise)
    }
}

Boolean Class — Wrapper for boolean

Boolean is the wrapper class for the boolean primitive. It is the simplest wrapper class — holding only two meaningful states: Boolean.TRUE and Boolean.FALSE. Like all wrapper classes, it allows boolean values to be used in Collections, Generics, and nullable contexts. Boolean also provides useful methods for parsing boolean strings and logical operations.

☕ JavaBooleanClass.java

public class BooleanClass {
    public static void main(String[] args) {

        // ── Creating Boolean ─────────────────────────────────────────────
        Boolean t = Boolean.TRUE;             // Cached constant
        Boolean f = Boolean.FALSE;            // Cached constant
        Boolean boxed = true;                 // Autoboxing
        Boolean fromVal = Boolean.valueOf(false); // Factory method

        // ── Parsing String to boolean ────────────────────────────────────
        boolean b1 = Boolean.parseBoolean("true");   // true
        boolean b2 = Boolean.parseBoolean("True");   // true (case-insensitive)
        boolean b3 = Boolean.parseBoolean("false");  // false
        boolean b4 = Boolean.parseBoolean("yes");    // false! (only 'true' → true)
        boolean b5 = Boolean.parseBoolean(null);     // false (no NPE)
        System.out.println(b1 + " " + b2 + " " + b3 + " " + b4); // true true false false

        // ── Boolean.valueOf vs parseBoolean ──────────────────────────────
        Boolean obj = Boolean.valueOf("true");   // Returns Boolean object
        boolean prim = Boolean.parseBoolean("true"); // Returns primitive

        // ── Boolean constants ────────────────────────────────────────────
        System.out.println(Boolean.TRUE);   // true
        System.out.println(Boolean.FALSE);  // false

        // ── Boolean in Collections ───────────────────────────────────────
        java.util.List<Boolean> flags = new java.util.ArrayList<>();
        flags.add(true);   // Autoboxing
        flags.add(false);
        flags.add(true);
        long trueCount = flags.stream().filter(Boolean::booleanValue).count();
        System.out.println("True count: " + trueCount);  // 2

        // ── Nullable boolean — 3-state logic ─────────────────────────────
        Boolean enabled = null; // null = unknown/not set
        if (Boolean.TRUE.equals(enabled)) {
            System.out.println("Enabled");
        } else if (Boolean.FALSE.equals(enabled)) {
            System.out.println("Disabled");
        } else {
            System.out.println("Not configured");  // null case
        }

        // ❌ DANGER: Unboxing null Boolean
        Boolean nullBool = null;
        // if (nullBool) { }  // NPE! unboxing null Boolean → boolean
        // Fix: use Boolean.TRUE.equals(nullBool) — null-safe
    }
}

Character Class — Wrapper for char

Character is the wrapper class for the char primitive. It provides a comprehensive set of static utility methods for testing and transforming individual characters — checking if a character is a letter, digit, whitespace, uppercase, lowercase, and converting between cases. These methods are Unicode-aware, handling characters from all scripts correctly.

☕ JavaCharacterClass.java

public class CharacterClass {
    public static void main(String[] args) {

        // ── Creating Character ───────────────────────────────────────────
        Character ch = Character.valueOf('A');  // Factory method
        Character boxed = 'Z';                  // Autoboxing

        // ── Testing character type ───────────────────────────────────────
        System.out.println(Character.isLetter('A'));      // true
        System.out.println(Character.isDigit('5'));       // true
        System.out.println(Character.isLetterOrDigit('!')); // false
        System.out.println(Character.isWhitespace(' ')); // true
        System.out.println(Character.isWhitespace('\t')); // true
        System.out.println(Character.isUpperCase('A'));  // true
        System.out.println(Character.isLowerCase('a'));  // true
        System.out.println(Character.isAlphabetic('B')); // true

        // ── Case conversion ──────────────────────────────────────────────
        System.out.println(Character.toUpperCase('a'));  // A
        System.out.println(Character.toLowerCase('Z'));  // z

        // ── Numeric value of digit character ─────────────────────────────
        System.out.println(Character.getNumericValue('7'));  // 7
        System.out.println(Character.getNumericValue('A'));  // 10 (hex A)

        // ── Character in String iteration ────────────────────────────────
        String word = "Hello123";
        int letterCount = 0, digitCount = 0;
        for (char c : word.toCharArray()) {
            if (Character.isLetter(c)) letterCount++;
            else if (Character.isDigit(c)) digitCount++;
        }
        System.out.println("Letters: " + letterCount + ", Digits: " + digitCount);
        // Letters: 5, Digits: 3

        // ── Constants ────────────────────────────────────────────────────
        System.out.println(Character.MAX_VALUE);  // \uFFFF (65535)
        System.out.println(Character.MIN_VALUE);  // \u0000 (0)
        System.out.println(Character.SIZE);       // 16 (bits)

        // ── char ↔ int conversion ────────────────────────────────────────
        char ch1 = 'A';
        int ascii = (int) ch1;        // Cast to int: 65
        char back = (char) (ascii + 1); // Cast back: 'B'
        System.out.println(ascii + " → " + back);  // 65 → B
    }
}

Long, Short & Byte Classes

Long, Short, and Byte follow the same pattern as Integer — each wraps its corresponding primitive, provides parsing and conversion methods, and exposes numeric constants. Long is commonly used for timestamps, IDs, and file sizes where int's range is insufficient. Short and Byte are rarely used in modern application code but appear in low-level I/O and data protocol handling.

☕ JavaLongShortByteClass.java

public class LongShortByteClass {
    public static void main(String[] args) {

        // ── Long — wraps long primitive ──────────────────────────────────
        Long l1 = Long.valueOf(9876543210L);
        Long l2 = Long.parseLong("123456789012");
        Long l3 = 42L;  // Autoboxing

        System.out.println(Long.MAX_VALUE);  // 9223372036854775807
        System.out.println(Long.MIN_VALUE);  // -9223372036854775808
        System.out.println(Long.toBinaryString(255L));  // 11111111
        System.out.println(Long.toHexString(255L));     // ff
        System.out.println(Long.compare(100L, 200L));   // negative

        // Common use: timestamps
        long now = System.currentTimeMillis();  // Returns long
        Long timestamp = now;  // Autoboxing to Long

        // ── Short — wraps short primitive ────────────────────────────────
        Short s1 = Short.valueOf((short) 1000);
        Short s2 = Short.parseShort("500");

        System.out.println(Short.MAX_VALUE);  // 32767
        System.out.println(Short.MIN_VALUE);  // -32768
        System.out.println(Short.SIZE);       // 16 (bits)

        // ── Byte — wraps byte primitive ──────────────────────────────────
        Byte b1 = Byte.valueOf((byte) 100);
        Byte b2 = Byte.parseByte("50");

        System.out.println(Byte.MAX_VALUE);   // 127
        System.out.println(Byte.MIN_VALUE);   // -128
        System.out.println(Byte.SIZE);        // 8 (bits)

        // ── Long caching — same as Integer: -128 to 127 ─────────────────
        Long la = 100L;
        Long lb = 100L;
        System.out.println(la == lb);        // true (cached range)

        Long lx = 200L;
        Long ly = 200L;
        System.out.println(lx == ly);        // false (outside cache)
        System.out.println(lx.equals(ly));   // true ✅ always use equals()

        // ── Number superclass methods — available on all numeric wrappers
        Long big = 123456789L;
        System.out.println(big.intValue());    // 123456789 (may truncate if > MAX_INT)
        System.out.println(big.doubleValue()); // 1.23456789E8
        System.out.println(big.floatValue());  // 1.2345679E8
    }
}

Integer Cache — The == Comparison Trap

One of the most famous and confusing Java interview topics: the Integer cache. The JVM caches Integer objects for values in the range -128 to 127. When autoboxing or calling Integer.valueOf() for values in this range, Java returns the same cached object. For values outside this range, a new object is created each time. This means == comparison on Integer objects gives true for small values and false for large ones — a behavior that looks random and baffles many developers.

☕ JavaIntegerCache.java

public class IntegerCache {
    public static void main(String[] args) {

        // ── Within cache range: -128 to 127 ─────────────────────────────
        Integer a = 100;  // Autoboxing → Integer.valueOf(100) → CACHED
        Integer b = 100;  // Same cached object returned
        System.out.println(a == b);       // true  (same object)
        System.out.println(a.equals(b));  // true  (same value)

        Integer x = 127;
        Integer y = 127;
        System.out.println(x == y);       // true  (127 is in cache)

        // ── Outside cache range ──────────────────────────────────────────
        Integer p = 128;  // Autoboxing → Integer.valueOf(128) → NEW object
        Integer q = 128;  // Another NEW object
        System.out.println(p == q);       // false! (different objects)
        System.out.println(p.equals(q));  // true ✅ (same value)

        Integer m = 1000;
        Integer n = 1000;
        System.out.println(m == n);       // false (new objects)
        System.out.println(m.equals(n));  // true ✅

        // ── The golden rule ──────────────────────────────────────────────
        // ❌ NEVER use == to compare Integer (or any wrapper) values
        // ✅ ALWAYS use .equals() for value comparison

        // ── Negative boundary ────────────────────────────────────────────
        Integer neg1 = -128;
        Integer neg2 = -128;
        System.out.println(neg1 == neg2);     // true (cached)

        Integer neg3 = -129;
        Integer neg4 = -129;
        System.out.println(neg3 == neg4);     // false (outside cache)
        System.out.println(neg3.equals(neg4)); // true ✅

        // ── Same caching applies to Long, Short, Byte ────────────────────
        Long la = 127L;
        Long lb = 127L;
        System.out.println(la == lb);  // true (cached)

        Long lx = 128L;
        Long ly = 128L;
        System.out.println(lx == ly);  // false (not cached)

        // ── Boolean: always cached (only 2 values) ───────────────────────
        Boolean bt1 = true;
        Boolean bt2 = true;
        System.out.println(bt1 == bt2);  // true (Boolean.TRUE is cached)
    }
}

Parsing & Type Conversion — String ↔ Primitive ↔ Wrapper

Parsing and conversion between String, primitive types, and wrapper objects is one of the most frequent operations in Java programs — reading user input, parsing configuration values, converting API responses, and building display strings. Each wrapper class provides a consistent set of methods for these conversions.

☕ JavaParsingConversion.java

public class ParsingConversion {
    public static void main(String[] args) {

        // ── String → Primitive (parse methods) ──────────────────────────
        int    i = Integer.parseInt("42");
        long   l = Long.parseLong("9876543210");
        double d = Double.parseDouble("3.14");
        float  f = Float.parseFloat("2.71");
        boolean b = Boolean.parseBoolean("true");
        byte   by = Byte.parseByte("100");
        short  s  = Short.parseShort("500");

        // ── String → Wrapper (valueOf methods) ──────────────────────────
        Integer wi = Integer.valueOf("42");
        Double  wd = Double.valueOf("3.14");
        Boolean wb = Boolean.valueOf("true");

        // ── Primitive → String ──────────────────────────────────────────
        String s1 = String.valueOf(42);         // "42"
        String s2 = Integer.toString(42);       // "42"
        String s3 = Double.toString(3.14);      // "3.14"
        String s4 = 42 + "";                   // "42" (concatenation — less preferred)

        // ── Wrapper → Primitive (xxxValue methods) ──────────────────────
        Integer wrappedInt = Integer.valueOf(100);
        int  asInt    = wrappedInt.intValue();
        long asLong   = wrappedInt.longValue();   // Widening
        double asDouble = wrappedInt.doubleValue(); // Widening

        // ── Numeric type conversion via wrappers ─────────────────────────
        // double → int (truncation)
        Double dbl = 9.99;
        int truncated = dbl.intValue();  // 9 (decimal dropped, not rounded)
        System.out.println(truncated);   // 9

        // String with radix parsing
        int fromBinary = Integer.parseInt("1111", 2);   // 15
        int fromHex    = Integer.parseInt("FF", 16);     // 255
        int fromOctal  = Integer.parseInt("17", 8);      // 15
        System.out.println(fromBinary + " " + fromHex + " " + fromOctal);

        // ── Error handling for invalid parse ─────────────────────────────
        String userInput = "not_a_number";
        try {
            int val = Integer.parseInt(userInput);
        } catch (NumberFormatException e) {
            System.out.println("Invalid input: " + userInput);
            // Handle gracefully — set default, show error, etc.
        }

        // ── Quick reference table of parse methods ───────────────────────
        // Byte.parseByte(str)     → byte
        // Short.parseShort(str)   → short
        // Integer.parseInt(str)   → int
        // Long.parseLong(str)      → long
        // Float.parseFloat(str)   → float
        // Double.parseDouble(str) → double
        // Boolean.parseBoolean(str) → boolean (null-safe, returns false for null)
    }
}

Wrapper Classes in Collections & Generics

The most fundamental reason wrapper classes exist in everyday Java code is their role in Collections and Generics. Java generics work only with reference types — you cannot write List<int> or Map<String, double>. Wrapper classes bridge this gap, letting you store primitives in type-safe collections. With autoboxing, the conversion is mostly invisible — but understanding what happens under the hood prevents performance mistakes and NPE surprises.

☕ JavaWrappersInCollections.java

import java.util.*;
import java.util.stream.*;

public class WrappersInCollections {
    public static void main(String[] args) {

        // ── List<Integer> — storing int values ───────────────────────────
        List<Integer> scores = new ArrayList<>();
        scores.add(95);   // Autoboxing: int → Integer.valueOf(95)
        scores.add(87);
        scores.add(72);
        scores.add(null); // Allowed — null is a valid Integer reference

        int first = scores.get(0); // Unboxing: Integer → int
        System.out.println("First: " + first);  // 95

        // ── Map<String, Integer> — score map ─────────────────────────────
        Map<String, Integer> playerScores = new HashMap<>();
        playerScores.put("Alice", 100);  // Autoboxing
        playerScores.put("Bob",   85);

        // ❌ NPE trap: get() returns null for missing key → unboxing fails
        // int carolScore = playerScores.get("Carol"); // NPE!
        // ✅ Fix: getOrDefault
        int carolScore = playerScores.getOrDefault("Carol", 0);
        System.out.println("Carol: " + carolScore);  // 0

        // ── Generics — wrapper as type parameter ─────────────────────────
        // ❌ INVALID: List<int> list — primitives not allowed
        // ✅ VALID:
        List<Integer>  ints    = new ArrayList<>();
        List<Double>   doubles = new ArrayList<>();
        List<Boolean>  bools   = new ArrayList<>();
        List<Character> chars  = new ArrayList<>();

        // ── Streams with wrapper types ───────────────────────────────────
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // sum — unboxing happens in mapToInt
        int sum = numbers.stream()
                         .mapToInt(Integer::intValue)  // Unboxing
                         .sum();
        System.out.println("Sum: " + sum);  // 15

        // ✅ IntStream — avoids boxing altogether for int streams
        int sumDirect = IntStream.rangeClosed(1, 5).sum();
        System.out.println("IntStream sum: " + sumDirect);  // 15

        // ── Sorting with wrapper comparison ──────────────────────────────
        List<Integer> unsorted = Arrays.asList(5, 1, 3, 2, 4);
        Collections.sort(unsorted);  // Integer implements Comparable<Integer>
        System.out.println(unsorted); // [1, 2, 3, 4, 5]

        // Reverse sort
        unsorted.sort(Comparator.reverseOrder());
        System.out.println(unsorted); // [5, 4, 3, 2, 1]

        // ── Filter nulls from Integer list ───────────────────────────────
        List<Integer> withNulls = Arrays.asList(1, null, 3, null, 5);
        List<Integer> clean = withNulls.stream()
                                        .filter(Objects::nonNull)
                                        .collect(Collectors.toList());
        System.out.println(clean); // [1, 3, 5]
    }
}

Autoboxing Performance — When to Avoid It

Autoboxing is convenient but not free. Each boxing operation allocates a new object on the heap (outside the -128 to 127 cache range), and each unboxing call adds a method invocation. In tight loops or high-throughput code, excessive autoboxing creates unnecessary garbage that increases GC pressure and degrades performance. Understanding where autoboxing happens implicitly is key to writing efficient Java.

☕ JavaAutoboxingPerformance.java

public class AutoboxingPerformance {

    // ❌ BAD: Autoboxing in tight loop — creates millions of Integer objects
    static long sumWithAutoboxing(int n) {
        Long sum = 0L;  // Long wrapper — not primitive long!
        for (int i = 0; i < n; i++) {
            sum += i;  // Unbox sum, add i (autobox i too), rebox result
            // Creates a new Long object on every iteration!
        }
        return sum;
    }

    // ✅ GOOD: Use primitive — zero boxing overhead
    static long sumWithPrimitive(int n) {
        long sum = 0L;  // primitive long
        for (int i = 0; i < n; i++) {
            sum += i;  // Pure primitive arithmetic — no objects
        }
        return sum;
    }

    public static void main(String[] args) {
        int N = 10_000_000;

        long start1 = System.currentTimeMillis();
        sumWithAutoboxing(N);
        long end1 = System.currentTimeMillis();
        System.out.println("Autoboxing: " + (end1 - start1) + "ms");
        // Typical: ~150–300ms

        long start2 = System.currentTimeMillis();
        sumWithPrimitive(N);
        long end2 = System.currentTimeMillis();
        System.out.println("Primitive:  " + (end2 - start2) + "ms");
        // Typical: ~5–15ms — 10–20x faster

        // ── Other performance pitfalls ───────────────────────────────────

        // ❌ BAD: List<Integer> for large numeric datasets
        java.util.List<Integer> list = new java.util.ArrayList<>();
        for (int i = 0; i < 100_000; i++) {
            list.add(i); // 100,000 Integer objects created
        }

        // ✅ BETTER: int[] for pure numeric data
        int[] arr = new int[100_000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i; // No objects — just array of primitives
        }

        // ✅ BETTER: IntStream for stream operations on int data
        long streamSum = java.util.stream.IntStream
                            .rangeClosed(0, 100_000)
                            .asLongStream()
                            .sum();
        System.out.println("Stream sum: " + streamSum);
    }

    // ✅ RULE: Use primitives for local variables, fields, and method parameters
    //         in performance-sensitive code. Use wrappers only when needed:
    //         Collections, Generics, null-check scenarios, utility methods.
}

Common Mistakes & Pitfalls — Wrapper Bugs That Fool Everyone

These are the most common wrapper class mistakes in Java — from beginners to experienced developers. Each one is subtle and frequently appears in coding interviews and production bug reports.

☕ JavaWrapperMistakes.java

import java.util.*;

// ❌ MISTAKE 1: Using == to compare Integer objects
Integer a = 1000;
Integer b = 1000;
System.out.println(a == b);      // false! (different objects)
System.out.println(a.equals(b)); // true ✅
// Fix: ALWAYS use .equals() for wrapper value comparison

// ❌ MISTAKE 2: Unboxing null wrapper — NPE
Map<String, Integer> map = new HashMap<>();
map.put("score", null);
int score = map.get("score");  // NPE! null.intValue()
// Fix:
Integer scoreObj = map.get("score");
int safeScore = (scoreObj != null) ? scoreObj : 0;
// Or: int safeScore = map.getOrDefault("score", 0);
// NOTE: getOrDefault returns null if value IS null (not missing)
// Use explicit null check for null-valued entries

// ❌ MISTAKE 3: Long sum declared as Long instead of long
Long total = 0L;  // Wrapper — causes boxing on every iteration
for (int i = 0; i < 1_000_000; i++) total += i; // Slow!
// Fix: long total = 0L;  — use primitive

// ❌ MISTAKE 4: Boolean unboxing in if — NPE on null
Boolean isEnabled = null;
// if (isEnabled) { }  // NPE! unboxing null Boolean
// Fix: use Boolean.TRUE.equals(isEnabled) — null-safe
if (Boolean.TRUE.equals(isEnabled)) { System.out.println("Enabled"); }

// ❌ MISTAKE 5: Assuming parseBoolean accepts 'yes'/'no'/'1'/'0'
System.out.println(Boolean.parseBoolean("yes"));  // false (not 'true'!)
System.out.println(Boolean.parseBoolean("1"));    // false
System.out.println(Boolean.parseBoolean("TRUE")); // true (case-insensitive)
// Only the string 'true' (any case) returns true — everything else is false

// ❌ MISTAKE 6: new Integer() instead of Integer.valueOf()
// new Integer(42) is DEPRECATED since Java 9 — creates new object every time
// Integer.valueOf(42) uses cache — preferred
// Fix: Integer i = Integer.valueOf(42); or Integer i = 42; (autoboxing)

// ❌ MISTAKE 7: NaN comparison with ==
double nan = Double.NaN;
System.out.println(nan == Double.NaN);    // false! NaN != NaN
System.out.println(Double.isNaN(nan));    // true ✅

// ❌ MISTAKE 8: Integer to int narrowing via wrapper — silent data loss
Long bigLong = 10_000_000_000L;
int narrowed = bigLong.intValue();  // Silent truncation — wrong value!
System.out.println(narrowed);       // 1410065408 — garbage value
// Fix: validate range before narrowing, or keep as long

Bad Practices & Anti-Patterns — What Senior Developers Reject

These anti-patterns represent common misuses of wrapper classes in professional Java code. Each one introduces bugs, performance degradation, or design problems that are hard to debug.

🚫

Using new Integer() / new Double() — Deprecated Constructors

new Integer(42), new Double(3.14), new Boolean(true) — all constructors on wrapper classes are deprecated since Java 9 and may be removed in a future release. They always create new heap objects, bypassing the Integer cache. Use Integer.valueOf(42), Double.valueOf(3.14), Boolean.valueOf(true), or simply autoboxing (Integer i = 42). Deprecated constructors are an easy item to flag in code reviews and interviews.

🚫

Using == to Compare Wrapper Objects

Integer a = 1000; Integer b = 1000; if (a == b) is reference comparison — not value comparison. It returns true accidentally for -128 to 127 (cached) and false for larger values, creating subtle bugs that only appear with certain data. Rule: always use .equals() or Integer.compare(a, b) for Integer value comparison. This is one of the most tested Java gotchas in interviews at all levels.

🚫

Using Wrapper Types in Performance-Critical Loops

Declaring Long sum = 0L in a loop that iterates millions of times creates a new Long object on every iteration (outside the cache range). This floods the heap and triggers GC. In any loop or computation-heavy method, use primitive types by default. Upgrade to wrapper only when you need the value in a Collection, need null, or need utility methods. Profile first — but the rule 'primitives in loops' is almost always correct.

🚫

Calling get() on Map Without Null Check Then Unboxing

map.get(key) returns null for missing keys. Immediately unboxing the result to a primitive — int val = map.get(key) — causes NPE when the key is missing. Always use getOrDefault(key, defaultValue) for maps with primitive value types, or store the result in an Integer first and check for null before unboxing. This is extremely common in code reviews and is a reliable source of production NPEs.

🚫

Ignoring NumberFormatException in parseInt()

Integer.parseInt() throws NumberFormatException for any non-numeric input including empty strings, strings with spaces, null strings, or strings with letters. In production code that parses user input or external data, always wrap parseInt() in try-catch or validate the string first. Never assume external input is a valid number. Consider utility methods like Apache Commons' NumberUtils.toIntOrDefault() for safer parsing in complex applications.

🚫

Using Wrapper Fields Instead of Primitives Without Reason

Declaring class fields as Integer age; instead of int age; when null is never a meaningful state adds unnecessary complexity — field can accidentally become null and cause NPE on access. Use primitive fields (int, double, boolean) as the default; switch to wrapper (Integer, Double, Boolean) only when null is a genuinely meaningful state that must be distinguished from zero or false. Document the null meaning with a comment when you do use wrapper fields.

Real-World Production Code Examples — Wrapper Classes in Context

The following examples show wrapper class patterns used in real enterprise Java and Spring Boot codebases — including entity models with nullable numeric fields, service-layer parsing with error handling, and stream-based aggregation.

☕ JavaProductEntity.java — Nullable Numeric Fields

package com.techsustainify.model;

import java.util.Objects;

@Entity
public class Product {

    @Id
    private Long id;             // Long — JPA IDs are nullable before persistence

    private String name;

    private double price;        // double — price always required, never null

    private Integer stock;       // Integer — null = 'stock unknown' (not 0)

    private Boolean featured;    // Boolean — null = 'not configured' (3-state)

    private Double discountRate; // Double — null = 'no discount applied'

    // ✅ Null-safe stock display — wrapper enables null check
    public String getStockDisplay() {
        if (stock == null) return "Stock unknown";
        if (stock == 0)    return "Out of stock";
        return stock + " units available";
    }

    // ✅ Null-safe discount calculation
    public double getEffectivePrice() {
        if (discountRate == null) return price;
        return price * (1.0 - discountRate);
    }

    // ✅ Null-safe boolean with 3-state logic
    public boolean isFeatured() {
        return Boolean.TRUE.equals(featured); // null → false, not NPE
    }

    // Getters / Setters omitted for brevity
}

☕ JavaConfigService.java — Safe Parsing from Properties

package com.techsustainify.config;

import java.util.Properties;
import java.util.Objects;

@Service
public class ConfigService {

    private final Properties props;

    public ConfigService(Properties props) {
        this.props = Objects.requireNonNull(props, "props must not be null");
    }

    // ✅ Safe int parsing with default — never throws to caller
    public int getIntProperty(String key, int defaultValue) {
        String val = props.getProperty(key);
        if (val == null || val.isBlank()) return defaultValue;
        try {
            return Integer.parseInt(val.trim());
        } catch (NumberFormatException e) {
            System.err.println("Invalid int for key '" + key + "': " + val);
            return defaultValue;
        }
    }

    // ✅ Safe double parsing
    public double getDoubleProperty(String key, double defaultValue) {
        String val = props.getProperty(key);
        if (val == null || val.isBlank()) return defaultValue;
        try {
            return Double.parseDouble(val.trim());
        } catch (NumberFormatException e) {
            return defaultValue;
        }
    }

    // ✅ Safe boolean parsing — accepts 'true'/'false' only
    public boolean getBooleanProperty(String key, boolean defaultValue) {
        String val = props.getProperty(key);
        if (val == null) return defaultValue;
        return Boolean.parseBoolean(val.trim()); // null-safe, returns false for invalid
    }

    // ✅ Typed config reader example
    public void loadConfig() {
        int    timeout  = getIntProperty("server.timeout",  30);
        double maxRetry = getDoubleProperty("retry.factor",  1.5);
        boolean debug   = getBooleanProperty("app.debug",    false);
        System.out.println(timeout + " " + maxRetry + " " + debug);
    }
}

☕ JavaScoreAggregator.java — Stream + Wrapper + Primitives

package com.techsustainify.analytics;

import java.util.*;
import java.util.stream.*;

@Service
public class ScoreAggregator {

    // ✅ Null-safe average from List<Integer> — filters nulls
    public OptionalDouble average(List<Integer> scores) {
        Objects.requireNonNull(scores, "scores must not be null");
        return scores.stream()
                     .filter(Objects::nonNull)    // Remove null entries
                     .mapToInt(Integer::intValue) // Unbox to IntStream
                     .average();                  // Returns OptionalDouble
    }

    // ✅ Sum using primitive IntStream — no boxing overhead
    public int totalScore(List<Integer> scores) {
        if (scores == null) return 0;
        return scores.stream()
                     .filter(Objects::nonNull)
                     .mapToInt(Integer::intValue)
                     .sum();
    }

    // ✅ Max score — null-safe with OptionalInt
    public OptionalInt maxScore(List<Integer> scores) {
        if (scores == null) return OptionalInt.empty();
        return scores.stream()
                     .filter(Objects::nonNull)
                     .mapToInt(Integer::intValue)
                     .max();
    }

    // ✅ Grouping with wrapper in Map — count per score range
    public Map<String, Long> scoreDistribution(List<Integer> scores) {
        Objects.requireNonNull(scores, "scores must not be null");
        return scores.stream()
                     .filter(Objects::nonNull)
                     .collect(Collectors.groupingBy(
                         s -> s >= 90 ? "A" : s >= 75 ? "B" : s >= 60 ? "C" : "F",
                         Collectors.counting()
                     ));
    }
}

Autoboxing Decision Flowchart — Primitive or Wrapper?

When writing Java code, use this decision process to choose between a primitive type and its wrapper class — getting this right prevents both NPEs and performance problems.

🔢 Need to store a numeric/boolean valueint, long, double, boolean, etc.

Start

📦 Store in Collection or use with Generics?List, Map, Set, <T> type param

YES

✅ Use Wrapper ClassList<Integer>, Map<String, Double>, etc.

❓ Null is a valid/meaningful state?e.g. 'not configured' vs 0/false

YES

✅ Use Wrapper ClassInteger, Double, Boolean — allows null

❓ Need utility methods?parseInt, valueOf, isNaN, compareTo...

YES

✅ Use Wrapper (static methods)Integer.parseInt(), Double.isNaN(), etc.

❓ Performance-critical loop or field?Millions of iterations, hot path

YES — use primitive

✅ Use Primitiveint, long, double — zero boxing overhead

✅ Use Primitive (default)Prefer primitive unless reason to use wrapper

Code Execution Flow — from source to output

Java Wrapper Classes Interview Questions — Beginner to Advanced

These questions are consistently asked in Java developer interviews at all levels — from campus placements to senior engineer rounds. Wrapper classes, autoboxing, and Integer caching are high-frequency topics.

Wrapper classes are object representations of Java's 8 primitive types: Byte, Short, Integer, Long, Float, Double, Character, Boolean. They are needed because: (1) Java Collections and Generics work only with objects — List<Integer> is valid, List<int> is not. (2) Utility methods for parsing, converting, and comparing — Integer.parseInt(), Double.isNaN(). (3) Null representation — Integer can be null; int cannot. (4) Reflection and APIs that expect Object type. All wrapper classes are in java.lang (auto-imported), are immutable, and final. They extend Number (except Boolean and Character) and implement Comparable<T>.

Autoboxing is automatic primitive → wrapper conversion by the Java compiler. Unboxing is automatic wrapper → primitive conversion. Introduced in Java 5. Examples: Integer a = 5 is autoboxing (compiler inserts Integer.valueOf(5)). int b = a is unboxing (compiler inserts a.intValue()). Autoboxing in collections: list.add(42) — int 42 autoboxed to Integer.valueOf(42). Unboxing in arithmetic: Integer x = 10; Integer y = 20; int sum = x + y — both unboxed, added, result is primitive. Key risk: unboxing a null wrapper throws NullPointerException. Performance risk: autoboxing in tight loops creates excessive heap objects.

Java caches Integer objects for values -128 to 127 via Integer.IntegerCache. Integer.valueOf() and autoboxing return the same cached object for values in this range. For 128 (outside cache), two separate objects are created — a == b compares references, so it prints false. a.equals(b) would print true. The cache range is a JVM optimization that cannot be changed at runtime except for the upper bound via -XX:AutoBoxCacheMax=N. The same caching applies to Byte, Short, Long (-128 to 127) and Character (0-127). Boolean always returns TRUE or FALSE constants. Double and Float have no cache. Rule: always use .equals() to compare wrapper values, never ==.

int: primitive, stored on stack, cannot be null, default value 0, no methods, ~4 bytes, fastest performance. Integer: object, stored on heap, can be null, default value null (for fields), has methods (parseInt, valueOf, compareTo), ~16 bytes + GC overhead. Cannot use int as generic type parameter (List<int> invalid) — must use Integer. int comparison with == works correctly; Integer comparison with == only works for cached range (-128 to 127). Use int for local variables, parameters, computations; use Integer for Collections, nullable values, and utility method access.

Integer.parseInt(String s) parses the string and returns a primitive int. Throws NumberFormatException for invalid input. Returns int — no object. Integer.valueOf(String s) parses the string and returns an Integer object. Uses cache for -128 to 127. Returns Integer — an object. Integer.valueOf(int i) wraps a primitive int in an Integer object (uses cache). parseInt is preferred when you need a primitive result — slightly faster since no boxing. valueOf is needed when you require an Integer object. Both throw NumberFormatException on invalid strings. null input to parseInt throws NumberFormatException; Boolean.parseBoolean(null) is special — returns false without throwing.

Yes — List<Integer> allows null elements (ArrayList does not prohibit null). Adding null: list.add(null) works fine. Retrieving and unboxing null: int val = list.get(index) where the element is null throws NullPointerException — unboxing null triggers intValue() on null. Similarly, iterating List<Integer> with for (int n : list) will NPE on any null element. Fix: filter nulls before processing — list.stream().filter(Objects::nonNull). Note: List.of() does NOT allow null — throws NullPointerException immediately on null element.

new Integer(42) is deprecated since Java 9 for two reasons: (1) It always creates a new heap object — it bypasses the Integer cache, wasting memory even for small values. (2) The object is not shared with the cached pool, so Integer caching optimizations don't apply. Use Integer.valueOf(42) instead — it returns a cached object for -128 to 127, and a new object only for values outside the cache range. Or use autoboxing: Integer i = 42 — the compiler calls Integer.valueOf() automatically. The same deprecation applies to new Double(), new Boolean(), new Long(), etc.

Output: true, false, true. a == b: true — 127 is in the Integer cache (-128 to 127). Both a and b point to the same cached Integer object. == compares references — same object, so true. c == d: false — 128 is outside the cache range. Integer.valueOf(128) creates a new object each time. c and d are different objects. == compares references — different objects, so false. c.equals(d): true — equals() compares integer values, not references. Both hold value 128, so equals() returns true. Key lesson: never use == for Integer value comparison; always use .equals().

NullPointerException is thrown on line int j = i. Auto-unboxing calls i.intValue() internally. Since i is null, this is equivalent to null.intValue() — NPE. Java 14+ helpful message: 'Cannot unbox null value'. This is one of the most common NPE causes in code that mixes Integer and int. Typical production scenario: int score = map.get('key') where key is missing — map.get() returns null, unboxing null Integer to int throws NPE. Fix: Integer result = map.get('key'); int score = result != null ? result : 0; or map.getOrDefault('key', 0).

Wrapper classes (Integer, Double, Boolean, etc.) are immutable — they cannot be modified after creation. Immutability makes them inherently thread-safe: multiple threads can read the same Integer object without synchronization because the value never changes. However, wrapper types themselves do not provide atomic operations. If you need to perform compound operations (read-modify-write) on a numeric value shared between threads — like a counter — use AtomicInteger, AtomicLong, or AtomicReference<Double> from java.util.concurrent.atomic. A local Integer variable or a field that is only ever assigned (not modified) is safe to use in concurrent code without additional synchronization.

Practice Questions — Test Your Wrapper Class Knowledge

Challenge yourself with these practice questions. Attempt each independently before reading the answer — active recall is proven to be 2–3x more effective than passive reading.

1. What is the output? Integer a = 100; Integer b = 100; Integer c = 200; Integer d = 200; System.out.println(a == b); System.out.println(c == d); System.out.println(c.equals(d));

Easy

✅ AnswerOutput: true, false, true. a == b: true — 100 is within Integer cache range (-128 to 127), both variables point to the same cached object. c == d: false — 200 is outside the cache range, two separate Integer objects are created by valueOf(), == compares different references. c.equals(d): true — equals() compares the integer value (200 == 200), not the object reference. Takeaway: never use == to compare Integer values; always use equals() or Integer.compare().

2. Will this code compile and run? What is the output or error? List<Integer> list = new ArrayList<>(); list.add(1); list.add(null); list.add(3); for (int n : list) { System.out.println(n); }

Easy

✅ AnswerCompiles fine. At runtime: prints 1, then throws NullPointerException on the null element. The enhanced for-loop on List<Integer> unboxes each element to int via intValue(). For 1 → 1 (prints fine). For null → null.intValue() → NPE. Java 14+ message: 'Cannot unbox null value'. Fix: use Integer n instead of int n in the loop, or filter nulls first: list.stream().filter(Objects::nonNull).forEach(System.out::println).

3. Find the performance bug and fix it: public long sumRange(int n) { Long sum = 0L; for (int i = 1; i <= n; i++) { sum += i; } return sum; }

Medium

✅ AnswerBug: Long sum = 0L declares a wrapper object. On every iteration of sum += i, the following happens: (1) sum is unboxed to primitive long, (2) i is added, (3) result is reboxed to a new Long object. For n = 10,000,000, this creates 10 million Long objects — massive GC pressure. Fix: change Long to long (primitive): public long sumRange(int n) { long sum = 0L; for (int i = 1; i <= n; i++) { sum += i; } return sum; }. This is a famous Java performance anti-pattern, often called 'accidental autoboxing in a loop'. It can make code 10-20x slower.

4. What does this print? System.out.println(Integer.parseInt("10", 2)); System.out.println(Integer.parseInt("FF", 16)); System.out.println(Integer.toBinaryString(10)); System.out.println(Integer.toHexString(255));

Medium

✅ AnswerOutput: 2, 255, 1010, ff. parseInt('10', 2): interprets '10' as binary (base 2) = 1×2 + 0×1 = 2. parseInt('FF', 16): interprets 'FF' as hexadecimal = 15×16 + 15 = 255. toBinaryString(10): converts decimal 10 to binary string = '1010'. toHexString(255): converts decimal 255 to hex string = 'ff' (lowercase). These base-conversion methods are useful for low-level programming and bit manipulation tasks.

5. Fix this code to be null-safe: Map<String, Integer> studentScores = new HashMap<>(); studentScores.put("Alice", 95); studentScores.put("Bob", null); int aliceScore = studentScores.get("Alice"); int carolScore = studentScores.get("Carol"); int bobScore = studentScores.get("Bob");

Medium

✅ AnswerIssues: aliceScore = map.get('Alice') works (95 is non-null, unboxing safe). carolScore = map.get('Carol') — key absent, returns null, unboxing null → NPE. bobScore = map.get('Bob') — value IS null (not absent), unboxing null → NPE. Note: getOrDefault('Bob', 0) also returns null here because the value stored IS null (not a missing key). Fix: Integer aliceObj = studentScores.get('Alice'); int aliceScore = aliceObj != null ? aliceObj : 0; Integer carolObj = studentScores.get('Carol'); int carolScore = carolObj != null ? carolObj : 0; Integer bobObj = studentScores.get('Bob'); int bobScore = bobObj != null ? bobObj : 0; Or use getOrDefault only for missing-key scenarios, and explicit null checks for null-valued entries.

6. What is the output? Explain the Boolean.parseBoolean behavior. System.out.println(Boolean.parseBoolean("true")); System.out.println(Boolean.parseBoolean("True")); System.out.println(Boolean.parseBoolean("TRUE")); System.out.println(Boolean.parseBoolean("yes")); System.out.println(Boolean.parseBoolean("1")); System.out.println(Boolean.parseBoolean(null)); System.out.println(Boolean.parseBoolean(""));

Medium

✅ AnswerOutput: true, true, true, false, false, false, false. Boolean.parseBoolean returns true ONLY when the string is 'true' in any case (equalsIgnoreCase('true')). Every other string — 'yes', '1', 'on', empty string, null — returns false without throwing an exception. This surprises many developers who expect 'yes', 'Y', or '1' to return true (as in many other languages or frameworks). Always explicitly document what string values your config/API accepts for boolean fields. If you need to accept 'yes'/'no', write a custom parser.

7. What is wrong? How do you fix it? Double price = getProductPrice(); // may return null if (price > 0.0) { applyDiscount(price); }

Hard

✅ AnswerBug: price > 0.0 unboxes price to double — if price is null, this throws NullPointerException. The comparison operator > triggers unboxing (price.doubleValue()), which NPEs on null. Fix A — null check first: if (price != null && price > 0.0) { applyDiscount(price); }. Fix B — use Optional: Optional.ofNullable(price).filter(p -> p > 0.0).ifPresent(this::applyDiscount);. Fix C — return primitive double from getProductPrice() if null is not meaningful (return 0.0 for unknown). Always be aware that comparison operators (<, >, <=, >=) on wrapper types trigger unboxing — null wrappers will NPE silently in comparisons.

8. Without running the code, what does this print? Integer x = 1000; Integer y = 1000; System.out.println(x == y); // Line A System.out.println(x.equals(y)); // Line B int a = x, b = y; System.out.println(a == b); // Line C System.out.println(x == (y + 0)); // Line D

Hard

✅ AnswerLine A: false — 1000 is outside Integer cache range, two separate objects, == is reference comparison. Line B: true — equals() compares values, 1000 == 1000. Line C: true — a and b are unboxed primitives (int), == on primitives compares values directly. 1000 == 1000 is true. Line D: true — y + 0 is an arithmetic expression with a primitive int (0). This triggers unboxing of y to primitive int, the result (1000) is a primitive int. Comparing Integer x with a primitive int triggers unboxing of x too. So it becomes 1000 == 1000 (primitive comparison) — true. Key insight: any arithmetic operation on a wrapper produces a primitive result, making subsequent == a primitive (value) comparison.

Conclusion — Wrapper Classes: Bridge Between Primitives and Objects

Wrapper classes are the bridge between Java's two type systems — the primitive world of int, double, and boolean, and the object world of Collections, Generics, and APIs. Autoboxing makes this bridge nearly invisible in day-to-day code, but professional Java developers understand exactly what happens under the hood — because the invisible conversions are precisely where the most subtle bugs and performance problems hide.

The two most important rules to internalize: (1) Always use .equals() — never == — to compare wrapper values, because Integer caching makes == deceptively correct for small values and silently wrong for large ones. (2) Prefer primitives by default — use wrapper classes only when Collections, Generics, null, or utility methods require them. Getting these two rules right eliminates the majority of wrapper-related bugs and performance problems in Java codebases.

Concept	Tool / Method	Key Rule
8 Wrapper Classes	Byte, Short, Integer, Long, Float, Double, Character, Boolean	All in java.lang — auto-imported
Autoboxing	Compiler inserts Integer.valueOf()	Primitive → Wrapper automatically
Unboxing	Compiler inserts intValue()	Null wrapper → NPE on unboxing
Integer cache	-128 to 127 cached	Always use .equals() not == for wrappers
String → primitive	Integer.parseInt(str)	Throws NumberFormatException if invalid
String → wrapper	Integer.valueOf(str)	Returns cached object where possible
Primitive → String	String.valueOf(n) or Integer.toString(n)	Prefer String.valueOf()
Performance	Use primitives in loops	Wrapper in loops = heap objects + GC
In Collections	List<Integer>, Map<String, Double>	Must use wrapper — primitives not allowed
Null-safe Boolean check	Boolean.TRUE.equals(obj)	Never unbox Boolean directly in if
Deprecated	new Integer() — avoid	Use Integer.valueOf() or autoboxing

Your next step: Java ArrayIndexOutOfBoundsException — where you'll apply defensive programming to array access and learn the boundaries of Java's array system. ☕

Frequently Asked Questions — Java Wrapper Classes

Wrapper classes in Java are object representations of the 8 primitive data types: byte → Byte, short → Short, int → Integer, long → Long, float → Float, double → Double, char → Character, boolean → Boolean. They are needed for Collections and Generics (which require objects), for utility methods like Integer.parseInt(), and when null must represent absence of a value. All wrapper classes are in java.lang, are immutable, and are declared final.

Autoboxing is the automatic conversion of a primitive to its wrapper class object by the Java compiler — e.g., int → Integer. Unboxing is the reverse — wrapper → primitive. The compiler inserts Integer.valueOf() for boxing and intValue() for unboxing. Key risk: unboxing a null wrapper throws NullPointerException. Introduced in Java 5. Performance risk: autoboxing in tight loops creates excess objects.

Java caches Integer objects for values -128 to 127. valueOf() and autoboxing return the same cached object in this range, so == returns true. For values outside this range, new objects are created and == returns false. Always use .equals() to compare Integer values — never ==. Same caching applies to Byte, Short, Long (-128 to 127) and Character (0 to 127). Boolean always caches TRUE and FALSE. Double and Float have no cache.

int is a primitive: stored on stack, cannot be null, default 0, no methods, 4 bytes, fastest. Integer is an object: stored on heap, can be null, default null for fields, has utility methods, ~16 bytes. Use int for local variables and computations; use Integer for Collections, nullable values, and utility method access. int comparison with == is value-based (correct); Integer comparison with == is reference-based (use .equals() instead).