Java Wrapper Classes — Complete Deep Guide

📖

Wrapper Class — Deep Concept

Java shuru karte waqt yeh topic bahut important hai

🧠 Wrapper Class Kya Hoti Hai?

Java mein 8 primitive types hain — int, char, double, float, boolean, byte, short, long. Ye objects nahi hain, sirf values hain. Lekin Java ek OOP language hai — collections, generics, methods mein objects chahiye.

Solution = Wrapper Class — ek "box" jo primitive ko object banata hai.

int → Integer (primitive ko object mein wrap kiya = Wrapper)

💡

3 Main Reasons — Wrapper Ki Zaroorat Kyun?

Reason 1 — Collections

Collections mein primitive directly nahi jaata:

// ❌ ERROR ArrayList<int> list = new ArrayList<>(); // ✅ CORRECT ArrayList<Integer> list = new ArrayList<>();

Reason 2 — Null Store

Primitive null store nahi kar sakta:

// ❌ ERROR int x = null; // ✅ CORRECT Integer x = null;

Reason 3 — Methods

Useful utility methods milte hain:

Integer.parseInt("100") Integer.valueOf(50) Integer.MAX_VALUE x.compareTo(y)

Primitive	Wrapper Class	Package	Common Use
`int`	Integer	java.lang	`Integer.parseInt("5")`
`double`	Double	java.lang	`Double.parseDouble("3.14")`
`char`	Character	java.lang	`Character.isDigit('5')`
`boolean`	Boolean	java.lang	`Boolean.parseBoolean("true")`
`byte`	Byte	java.lang	`Byte.MAX_VALUE = 127`
`short`	Short	java.lang	`Short.MAX_VALUE = 32767`
`long`	Long	java.lang	`Long.MAX_VALUE`
`float`	Float	java.lang	`Float.parseFloat("1.5")`

📦 Autoboxing — Primitive → Object

Compiler automatically primitive ko Wrapper object mein convert karta hai. Java 1.5 se automatic.

int x = 10; Integer obj = x; // Autoboxing! // Compiler peeche karta hai: // Integer.valueOf(x)

📤 Unboxing — Object → Primitive

Compiler automatically Wrapper object ko primitive mein convert karta hai.

Integer obj = 50; int x = obj; // Unboxing! // Compiler peeche karta hai: // obj.intValue()

💻

Program 1 — Basic Wrapper Class Creation

File: BasicWrapper.java — Teen tarike se Wrapper object banana

🎯 Is Program Mein Kya Seekhoge?

Wrapper class object teen tarike se banana — Constructor, valueOf(), Autoboxing
instanceof se check karna ki object hai ya nahi
getClass().getName() — runtime class name dekhna
Primitive vs Wrapper ka fark clearly samajhna

PROGRAM 1BasicWrapper.java

BasicWrapper.javaWrapper Creation — 3 Ways

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

        // Primitive values
        int     a    = 10;
        double  b    = 3.14;
        char    c    = 'A';
        boolean flag = true;

        // Wrapper objects - 3 tarike bante hain
        // Tarika 1: Constructor (old way - Java 9 se deprecated)
        Integer obj1 = new Integer(10); // works but old style

        // Tarika 2: valueOf() - recommended way
        Integer   obj2 = Integer.valueOf(10);
        Double    obj3 = Double.valueOf(3.14);
        Character obj4 = Character.valueOf('A');
        Boolean   obj5 = Boolean.valueOf(true);

        // Tarika 3: Autoboxing (simplest - Java 1.5+)
        Integer obj6 = 10; // compiler khud valueOf() call karta hai

        System.out.println("int value: " + a);
        System.out.println("Integer object: " + obj2);
        System.out.println("Double object: " + obj3);
        System.out.println("Character object: " + obj4);
        System.out.println("Boolean object: " + obj5);

        // Object hai to methods call ho sakte hain
        System.out.println("obj2 class name: " + obj2.getClass().getName());
        System.out.println("Is obj2 an object? "
            + (obj2 instanceof Integer)); // true
    }
}

⚡ Expected Output

int value: 10
Integer object: 10
Double object: 3.14
Character object: A
Boolean object: true
obj2 class name: java.lang.Integer
Is obj2 an object? true

💬 Hinglish Explanation

Teen tarike se Wrapper banana:
1. Constructor: new Integer(10) — purana tarika, Java 9 se deprecated hai lekin abhi bhi compile hota hai.
2. valueOf(): Integer.valueOf(10) — recommended tarika. Cache use karta hai (-128 to 127 ke liye) isliye memory efficient hai.
3. Autoboxing: Integer obj6 = 10 — sabse simple! Compiler peeche Integer.valueOf(10) call karta hai — tumhe kuch nahi likhna.

instanceof Integer → true — confirm ho gaya ki yeh ab ek object hai, sirf primitive nahi!
getClass().getName() → "java.lang.Integer" — runtime pe class ka poora naam aata hai — proof ki object ban gaya.

💻

Program 2 — Autoboxing & Unboxing (Most Important!)

File: AutoboxUnbox.java — Compiler peeche kya karta hai samjho

🎯 Is Program Mein Kya Seekhoge?

Autoboxing — primitive se automatically Wrapper object banana
Unboxing — Wrapper object se automatically primitive milna
Arithmetic operations mein auto unboxing kaise hota hai
Method call mein auto conversion — Integer pass kiya, int expect karta hai

PROGRAM 2AutoboxUnbox.java

AutoboxUnbox.javaAutoboxing + Unboxing + Arithmetic

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

        // ========== AUTOBOXING ==========
        // primitive → Wrapper Object (automatic)
        int p1 = 100;
        Integer obj1 = p1;        // Autoboxing
        Integer obj2 = 200;       // Direct autoboxing
        Double  obj3 = 9.99;      // Double autoboxing
        Boolean obj4 = true;      // Boolean autoboxing

        System.out.println("=== Autoboxing ===");
        System.out.println("int → Integer: " + obj1);
        System.out.println("Direct → Integer: " + obj2);
        System.out.println("double → Double: " + obj3);
        System.out.println("boolean → Boolean: " + obj4);

        // ========== UNBOXING ==========
        // Wrapper Object → primitive (automatic)
        int     x = obj1;        // Unboxing
        double  y = obj3;        // Unboxing
        boolean z = obj4;        // Unboxing

        System.out.println("\n=== Unboxing ===");
        System.out.println("Integer → int: " + x);
        System.out.println("Double → double: " + y);
        System.out.println("Boolean → boolean: " + z);

        // ========== ARITHMETIC WITH WRAPPER ==========
        Integer num1 = 50;
        Integer num2 = 30;

        // Unboxing automatically hota hai arithmetic mein
        int     sum    = num1 + num2;     // unbox, add, result int
        Integer result = num1 + num2;     // unbox, add, autobox back

        System.out.println("\n=== Arithmetic ===");
        System.out.println("50 + 30 = " + sum);
        System.out.println("Integer result = " + result);

        // ========== METHOD MEIN AUTO ==========
        System.out.println("\n=== Method Call ===");
        printPrimitive(obj1); // Integer pass kiya, int expect karta hai - auto unbox
    }

    static void printPrimitive(int n) { // int parameter
        System.out.println("Received primitive: " + n);
    }
}

⚡ Expected Output

=== Autoboxing ===
int → Integer: 100
Direct → Integer: 200
double → Double: 9.99
boolean → Boolean: true

=== Unboxing ===
Integer → int: 100
Double → double: 9.99
Boolean → boolean: true

=== Arithmetic ===
50 + 30 = 80
Integer result = 80

=== Method Call ===
Received primitive: 100

💬 Hinglish Explanation

Autoboxing — compiler peeche kya karta hai:
Integer obj1 = p1 → compiler Integer.valueOf(p1) call karta hai. Tumhe manually likhna nahi — Java 1.5 ke baad automatic hai.

Unboxing — compiler peeche kya karta hai:
int x = obj1 → compiler obj1.intValue() call karta hai automatically.

Arithmetic mein unboxing: num1 + num2 — pehle dono unbox hote hain (intValue()), phir add hota hai, phir agar Integer result mein store karo to autobox bhi hota hai — teen kaam ek line mein!

Method call: printPrimitive(obj1) — method int expect karta hai, Integer diya → auto unboxing! Java compiler sab handle karta hai.

💻

Program 3 — Important Methods of Wrapper Classes

File: WrapperMethods.java — parseInt, valueOf, xxxValue, toString, compareTo

🎯 Is Program Mein Kya Seekhoge?

parseInt() — String ko primitive mein convert karna (sabse zyada use!)
valueOf() — primitive ya String ko Wrapper object mein
xxxValue() — Wrapper object ko primitive mein — intValue, doubleValue, floatValue, longValue
toString() — primitive ko String mein convert karna
MAX_VALUE / MIN_VALUE constants, compareTo(), equals()

⚠️ Note (Document mein typo tha): Original document mein pehle floatVal() galat likha tha — sahi method hai floatValue(). Document ne khud yeh note kiya aur corrected version diya. Neeche woh corrected clean version hai jo online compiler pe directly run hoga!

PROGRAM 3WrapperMethods.java

WrapperMethods.javaAll Important Methods — Corrected Version

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

        // parseInt - String to primitive
        int     a = Integer.parseInt("123");
        double  b = Double.parseDouble("3.14");
        boolean c = Boolean.parseBoolean("true");
        System.out.println("parseInt: " + a);
        System.out.println("parseDouble: " + b);
        System.out.println("parseBoolean: " + c);

        // valueOf - primitive/String to Wrapper
        Integer obj1 = Integer.valueOf(50);
        Integer obj2 = Integer.valueOf("789");
        System.out.println("valueOf int: " + obj1);
        System.out.println("valueOf String: " + obj2);

        // xxxValue - Wrapper to primitive
        Integer obj3 = Integer.valueOf(99);
        System.out.println("intValue: "    + obj3.intValue());
        System.out.println("doubleValue: " + obj3.doubleValue());
        System.out.println("floatValue: "  + obj3.floatValue());
        System.out.println("longValue: "   + obj3.longValue());

        // toString
        System.out.println("toString: " + Integer.toString(200));

        // Constants
        System.out.println("INT MAX: " + Integer.MAX_VALUE);
        System.out.println("INT MIN: " + Integer.MIN_VALUE);

        // compareTo
        Integer x = 10, y = 20;
        System.out.println("compareTo: " + x.compareTo(y)); // negative = x < y
        System.out.println("equals: "    + x.equals(y));     // false
    }
}

⚡ Expected Output

parseInt: 123
parseDouble: 3.14
parseBoolean: true
valueOf int: 50
valueOf String: 789
intValue: 99
doubleValue: 99.0
floatValue: 99.0
longValue: 99
toString: 200
INT MAX: 2147483647
INT MIN: -2147483648
compareTo: -1
equals: false

💬 Hinglish Explanation

parseInt("123") → String se primitive int milta hai. User input hamesha String hoti hai — isliye yeh method sabse zyada use hota hai!

valueOf(50) vs valueOf("789") — dono Wrapper object return karte hain. parseInt primitive return karta hai — yahi dono ka fark hai.

intValue() → 99, doubleValue() → 99.0, floatValue() → 99.0, longValue() → 99 — ek hi Integer object se alag alag primitive types milte hain! Type conversion automatic hoti hai.

compareTo(y) → -1 matlab x < y. 0 hota to equal, positive hota to x > y. HAMESHA equals() use karo value compare karne ke liye — kabhi == nahi!

💻

Program 4 — Wrapper with Collections (Real Reason!)

File: WrapperCollection.java — Isliye Wrapper chahiye — ArrayList, null, parsing

🎯 Is Program Mein Kya Seekhoge?

ArrayList mein Wrapper kyun — primitive direct nahi jaata
Autoboxing ArrayList mein — list.add(10) se int automatically Integer banta hai
for-each loop mein automatic unboxing
Null value store karna — Wrapper kar sakta hai, primitive nahi
String input ko parse karke collection mein store karna

PROGRAM 4WrapperCollection.java

WrapperCollection.javaArrayList + Null + Auto + Parsing

import java.util.ArrayList;

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

        // ArrayList mein primitive directly nahi jaata
        // ArrayList<int> list = new ArrayList<>(); // ❌ ERROR

        ArrayList<Integer> list = new ArrayList<>(); // ✅ Wrapper use karo

        // Autoboxing - int values automatically Integer bante hain
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);

        System.out.println("List: " + list);

        // Unboxing - Integer automatically int banta hai
        int sum = 0;
        for (int num : list) { // unboxing har iteration mein
            sum += num;
        }
        System.out.println("Sum: " + sum);

        // Null store karna - primitive nahi kar sakta
        Integer nullVal = null; // ✅ Wrapper null store kar sakta hai
        list.add(nullVal);
        System.out.println("With null: " + list);

        // Wrapper methods use karna
        System.out.println("Max in list (manual): " + findMax(list));

        // String input convert karke store karna
        ArrayList<Double> marks = new ArrayList<>();
        String[] markStrings = {"85.5", "90.0", "78.5", "95.0"};
        for (String s : markStrings) {
            marks.add(Double.parseDouble(s)); // String → double → Double (autobox)
        }
        System.out.println("Marks: " + marks);
    }

    static int findMax(ArrayList<Integer> list) {
        int max = Integer.MIN_VALUE;
        for (Integer n : list) {
            if (n != null && n > max) { // unboxing
                max = n;
            }
        }
        return max;
    }
}

⚡ Expected Output

List: [10, 20, 30, 40, 50]
Sum: 150
With null: [10, 20, 30, 40, 50, null]
Max in list (manual): 50
Marks: [85.5, 90.0, 78.5, 95.0]

💬 Hinglish Explanation

ArrayList<int> → ERROR kyu? Java Generics mein sirf reference types (objects) allowed hain — primitives nahi. Integer ek class hai — object hai — isliye kaam karta hai.

Autoboxing in add(): list.add(10) → compiler peeche list.add(Integer.valueOf(10)) karta hai. Tumhe manually nahi karna padta.

Unboxing in for-each: for (int num : list) → har iteration mein Integer.intValue() auto call hota hai.

Null check kyu zaroori: findMax() mein if (n != null) — agar null ko unbox karo (n > max) to NullPointerException aayega! Null check pehle karo hamesha.

Parsing chain: Double.parseDouble(s) → String se double milta hai → autobox hoke Double object banta hai → marks.add() mein jaata hai. Ek line mein teen kaam!

💻

Program 5 — Immutability + Integer Cache (Tricky!)

File: ImmutableCache.java — Interview ka favorite — sab confuse hote hain isme

🎯 Is Program Mein Kya Seekhoge?

Wrapper classes immutable hain — value "change" nahi hoti, naya object banta hai
Integer Cache — Java -128 se 127 tak cache karta hai — == true deta hai
127 se bahar — == false, .equals() true — kyu? Deep samjhenge!
NullPointerException — null Wrapper unbox karne pe
Best Practice — hamesha .equals() use karo

PROGRAM 5ImmutableCache.java

ImmutableCache.javaCache + Immutability + NPE + Best Practice

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

        // ========== IMMUTABILITY ==========
        // Wrapper classes immutable hain - value change nahi hoti
        Integer obj = Integer.valueOf(10);
        System.out.println("Before: " + obj); // 10

        obj = obj + 5; // Ye obj ko modify NAHI karta
        // Internally: unbox(10) + 5 = 15, phir new Integer(15) banta hai
        System.out.println("After: " + obj); // 15 (naya object ban gaya)

        // ========== INTEGER CACHE (-128 to 127) ==========
        // Java cache karta hai -128 to 127 range ke Integer objects
        Integer a = 100;
        Integer b = 100;
        System.out.println("\n=== Cache Range (-128 to 127) ===");
        System.out.println(a == b);      // TRUE - same cached object
        System.out.println(a.equals(b)); // TRUE

        Integer c = 200; // cache range se bahar
        Integer d = 200;
        System.out.println("\n=== Outside Cache (>127) ===");
        System.out.println(c == d);      // FALSE - alag alag objects bane
        System.out.println(c.equals(d)); // TRUE - value same hai

        // Lesson: Wrapper compare karne ke liye HAMESHA .equals() use karo
        System.out.println("\n=== Best Practice ===");
        Integer x = 1000;
        Integer y = 1000;
        System.out.println("== result: "      + (x == y));       // false (unreliable)
        System.out.println(".equals result: " + x.equals(y)); // true (reliable)

        // ========== NULL UNBOXING DANGER ==========
        System.out.println("\n=== Null Danger ===");
        Integer nullObj = null;
        try {
            int val = nullObj; // NullPointerException! unboxing null nahi ho sakta
        } catch (NullPointerException e) {
            System.out.println("NullPointerException caught! null unbox nahi hota.");
        }

        // Safe way
        if (nullObj != null) {
            int val = nullObj;
        } else {
            System.out.println("Safe: null check kiya pehle.");
        }
    }
}

⚡ Expected Output

Before: 10
After: 15

=== Cache Range (-128 to 127) ===
true
true

=== Outside Cache (>127) ===
false
true

=== Best Practice ===
== result: false
.equals result: true

=== Null Danger ===
NullPointerException caught! null unbox nahi hota.
Safe: null check kiya pehle.

💬 Hinglish Explanation

Immutability — obj = obj + 5 mein kya hua exactly:
Step 1: obj.intValue() → 10 unbox hua
Step 2: 10 + 5 = 15 calculate hua
Step 3: new Integer(15) naya object bana heap pe
Step 4: obj reference us naye object ko point karne laga
Original Integer(10) object heap mein unchanged raha! Value nahi badli — reference badla!

Integer Cache ka secret: JVM startup pe -128 se 127 tak ke Integer objects ek baar bana ke memory pool mein rakh leta hai. Integer a = 100 → pool se same object milta hai. Integer b = 100 → same pool object milta hai. Isliye a == b → true (same memory address!).

200 se bahar kyu false: Integer c = 200 → pool mein nahi → heap pe naya object bana. Integer d = 200 → aur ek naya object bana. Do alag objects → c == d → false. Value same hai → c.equals(d) → true.

NullPointerException: Integer nullObj = null ke baad int val = nullObj → compiler nullObj.intValue() try karta hai → null pe method call → NPE crash! Isliye pehle null check karo.

📊

Conversion Chart — Sabse Important

Exam mein hamesha kaam aata hai — yaad kar lo

🔄 Conversion Reference

String ──→ int : Integer.parseInt("100") String ──→ double : Double.parseDouble("3.14") String ──→ boolean : Boolean.parseBoolean("true") String ──→ Integer : Integer.valueOf("100") int ──→ String : Integer.toString(100) OR "" + 100 int ──→ Integer : Integer.valueOf(100) OR autoboxing Integer ──→ int : obj.intValue() OR unboxing Integer ──→ String : obj.toString()

Method	Kya karta hai	Return Type	Example
`parseInt()`	String → int	int (primitive)	`Integer.parseInt("5")` → 5
`valueOf()`	int/String → Integer	Integer (object)	`Integer.valueOf(5)` → Integer
`intValue()`	Integer → int	int (primitive)	`obj.intValue()` → 5
`doubleValue()`	Integer → double	double	`obj.doubleValue()` → 5.0
`toString()`	int → String	String	`Integer.toString(5)` → "5"
`compareTo()`	Do wrappers compare	int (-1/0/1)	`a.compareTo(b)`
`equals()`	Value equality	boolean	`a.equals(b)`
`MAX_VALUE`	Sabse bada value	int constant	`Integer.MAX_VALUE` → 2147483647
`MIN_VALUE`	Sabse chota value	int constant	`Integer.MIN_VALUE` → -2147483648

⚠️

4 Tricky Rules — Hamesha Yaad Rakho

Ye rules exam aur interview mein pakka poocha jaata hai

⚠️ Rule 1 — == vs .equals()

Wrapper objects compare karne ke liye hamesha .equals() use karo. == sirf references compare karta hai (same object ya nahi). .equals() values compare karta hai — hamesha reliable!

⚠️ Rule 2 — Integer Cache (-128 to 127)

Java -128 se 127 tak Integer objects cache karta hai. Us range mein == true deta hai — bahar false. Isliye hamesha .equals() use karo — reliable aur safe!

⚠️ Rule 3 — Null Unboxing Danger

null wrapper ko unbox karne se NullPointerException aata hai. Pehle null check karo: if (obj != null) { int x = obj; }

⚠️ Rule 4 — Immutability

Wrapper classes immutable hain — obj = obj + 5 mein naya object banta hai, purana unchanged rehta hai. Reference change hota hai, original object nahi!

⭐

Interview / Exam Questions

Ye sab poochha jaata hai — ache se padho aur samjho

Q1 · Wrapper class kyu chahiye — primitive kyu nahi kaam karta?

Collections mein sirf objects jaate hain — ArrayList<int> compile error, ArrayList<Integer> chalega. Null store karna ho — int x = null error, Integer x = null valid. Plus useful methods milte hain jaise parseInt(), compareTo(), MAX_VALUE.

Q2 · Autoboxing aur Unboxing exactly kya hota hai?

Autoboxing: Integer obj = 10 → compiler peeche Integer.valueOf(10) call karta hai.
Unboxing: int x = obj → compiler peeche obj.intValue() call karta hai. Java 1.5 ke baad automatic hai.

Q3 · parseInt() aur valueOf() mein kya difference hai?

Integer.parseInt("123") → returns primitive int.
Integer.valueOf("123") → returns Wrapper Integer object.
Jab primitive chahiye → parseInt(). Jab object chahiye → valueOf().

Q4 · Integer Cache kya hota hai? 200 ke liye == false kyu?

JVM startup pe -128 se 127 tak ke Integer objects ek baar bana ke pool mein rakh deta hai. Integer a = 100 aur Integer b = 100 — dono same cached object → a == b → true. Integer c = 200 aur Integer d = 200 — do alag naye heap objects → c == d → false. c.equals(d) → true kyunki value same. Isliye hamesha .equals()!

Q5 · NullPointerException kab aata hai Wrapper mein?

Integer obj = null ke baad int x = obj → compiler obj.intValue() try karta hai → null pe method call → NullPointerException! Safe tarika: if (obj != null) { int x = obj; }

Q6 · Wrapper classes immutable kyu hain?

obj = obj + 5 mein — original Integer(10) change nahi hota! Process: unbox(10) + 5 = 15 → naya Integer(15) banta hai → obj us naye object ko point karta hai. Purana object unchanged raha. Immutability thread-safety aur Integer pool caching ke liye zaroori hai.

Q7 · String ko int mein convert karne ka tarika?

int x = Integer.parseInt("123"); — sabse common tarika. Scanner se input String milti hai — isliye yeh conversion bahut zaroori hai. parseInt("abc") → NumberFormatException — try-catch use karo!

Q8 · compareTo() kya return karta hai?

Negative → a < b | Zero → a == b | Positive → a > b
Example: Integer.valueOf(10).compareTo(20) → -1 (kyunki 10 < 20). Sorting ke liye use hota hai.

⚡ 30 Second Quick Revision

Wrapper kyu: Collections · Null store · Methods
Autoboxing: Integer obj = 10 → compiler: Integer.valueOf(10)
Unboxing: int x = obj → compiler: obj.intValue()
parseInt: String → primitive | valueOf: String/primitive → Wrapper object
Cache: -128 to 127 → same object → == true | Bahar → alag objects → == false
Best Practice: Hamesha .equals() · Null check karo unboxing se pehle