Wrapper classes in Java are object representations of the eight primitive data types (int, double, char, boolean, byte, short, long, float). They enable primitives to be used in contexts that require objects, such as collections, generic types, and as method return types.

Primitive Types and Corresponding Wrapper Classes

• int ↔ Integer
• double ↔ Double
• char ↔ Character
• boolean ↔ Boolean
• byte ↔ Byte
• short ↔ Short
• long ↔ Long
• float ↔ Float

Key characteristics of wrapper classes include:

1. Constructors: They provide constructors to create objects from primitive values.
2. Static valueOf(): A static method to convert a primitive to its wrapper object.
3. Instance xxxValue(): Methods like intValue() to extract the primitive value from the wrapper object.
4. Caching: For performance, the JVM caches instances of Integer and Long within a common range (typically -128 to 127).
5. Value Comparison: The equals() method is overridden to compare the wrapped values, not object references.

public class WrapperDemo {
    public static void main(String[] args) {
        // Creating wrapper objects using constructors (deprecated in newer Java)
        Integer intObj = new Integer(42);
        Double dblObj = new Double(3.14159);

        // Preferred: Using static valueOf method
        Integer anotherInt = Integer.valueOf(100);
        Double anotherDbl = Double.valueOf(99.5);

        // Converting back to primitives
        int primInt = intObj.intValue();
        double primDbl = dblObj.doubleValue();

        // Comparing values
        boolean sameValue = intObj.equals(anotherInt);

        System.out.println("Primitive int: " + primInt);
        System.out.println("Primitive double: " + primDbl);
        System.out.println("Integer values equal? " + sameValue);
    }
}

Core Featurse of Wrapper Classes

1. Autoboxing and Unboxing:
   • Autoboxing: Automatic conversion of a primitive to its wrapper object (e.g., Integer val = 5;).
   • Unboxing: Automatic extraction of the primitive from its wrapper object (e.g., int x = val;).
2. Representation Range: Can represent all values of their corresponding primitive, plus null.
3. Use in Collections: Essential for storing numerical/boolean data in collections like ArrayList<Integer>.
4. Interface Implementation: Many implement Comparable for sorting. Character implements CharSequence.
5. Utility Methods: Provide useful static methods (e.g., Character.isDigit(), Integer.parseInt()).
6. String Conversion: Methods like Integer.toString(int) facilitate conversion to/from String.
7. Null Safety: Objects can be null, unlike primitives.
8. Constants: Define useful constants like Integer.MAX_VALUE and Double.NaN.

Primitive Types vs. Wrapper Classes

Aspect	Primitive Type	Wrapper Class
Nature	Fundamental data type	Object
Storage	Holds value directly	Holds reference to object containing value
Default Value	Yes (e.g., 0 for int)	null
Memory/Performance	Less memory, faster	More memory, object overhead
Usage	Simple arithmetic, local variables	Collections, generics, nullable values

public class PrimitiveWrapperComparison {
    public static void main(String[] args) {
        // Primitive variable
        int simpleNumber = 50;
        // Wrapper object
        Integer objectNumber = Integer.valueOf(75);

        // Autoboxing: primitive -> wrapper
        Integer autoBoxed = simpleNumber; // Equivalent to Integer.valueOf(simpleNumber)

        // Unboxing: wrapper -> primitive
        int extracted = objectNumber; // Equivalent to objectNumber.intValue()

        System.out.println("Primitive: " + simpleNumber);
        System.out.println("Wrapper Object: " + objectNumber);
        System.out.println("Autoboxed Result: " + autoBoxed);
        System.out.println("Unboxed Result: " + extracted);
    }
}

Commonalities Among Wrapper Classes

All wrapper classes share several traits:

• Inheritance: All extend java.lang.Number (except Boolean and Character).
• Factory Methods: Provide static valueOf() methods for object creation.
• Parsing: Offer parseXxx(String s) static methods (e.g., Double.parseDouble("12.5")).
• Overridden Object methods: equals(), hashCode(), and toString() behave based on the wrapped value.
• Type Conversion: Provide methods like intValue(), doubleValue() for cross-type conversion.
• Comparable: Most implement Comparable<T>.

Autoboxing and Unboxing in Detail

Autoobxing and unboxing simplify code by handling conversions implicitly.

import java.util.ArrayList;
import java.util.List;

public class AutoBoxUnboxDemo {
    public static void main(String[] args) {
        // Autoboxing examples
        List<Integer> numberList = new ArrayList<>();
        numberList.add(10);   // Autoboxing: int -> Integer
        numberList.add(20);
        Integer wrappedNum = 30; // Autoboxing on assignment

        // Unboxing examples
        int first = numberList.get(0); // Unboxing: Integer -> int
        int sum = wrappedNum + 5;      // Unboxing for arithmetic

        // Caution: Potential NullPointerException
        Integer possibleNull = null;
        // int risky = possibleNull; // This line would throw NullPointerException at runtime

        System.out.println("First element (unboxed): " + first);
        System.out.println("Sum with unboxed value: " + sum);

        // Performance consideration: unnecessary boxing in loops
        Long total = 0L; // Wrapper object
        for (int i = 0; i < 10000; i++) {
            total += i; // Inefficient: involves unboxing, addition, then re-boxing each iteration
        }
        // Better: use primitive 'long total = 0L;' for such loops.
    }
}

Important Considerations:

• Performance: Frequent autoboxing/unboxing in tight loops can create overhead due to object creation.
• Null Handling: Unboxing a null wrapper reference causes a NullPointerException.
• Equality Checks: Use equals() for value comparison between wrapper objects. The == operator compares object references, which may fail for values outside the cached range.

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

Integer c = 200;
Integer d = 200;
System.out.println(c == d); // False (different objects)
System.out.println(c.equals(d)); // True (value comparison)