Wrapper Class in Java

1️⃣What is a Wrapper Class in Java?

A Wrapper Class in Java is an object representation of primitive data types. Since Java is an object-oriented language, sometimes we need to treat primitive types like objects (e.g., when working with collections such as ArrayList).

2️⃣.Why Use Wrapper Classes?

• Needed for working with Collections API (e.g., ArrayList<Integer>).
• Provide utility methods (e.g., Integer.parseInt(), Double.toString()).
• Allow converting between Strings and primitive types.
• Offer methods for type conversions and constant values.

3️⃣Autoboxing and Unboxing

3.1 Autoboxing

In Java, Autoboxing refers to the automatic conversion of a primitive type (like int, double, or boolean) into its corresponding Wrapper class object (Integer, Double, Boolean).

This process happens automatically by the Java compiler, so you don’t need to manually wrap primitive values into objects. This is especially useful when you work with collections (like ArrayList) that can only store objects, not primitive types.

⚡ How Does It Work?

Let’s say you have a primitive int value, and you want to store it in an Integer object. Instead of calling a constructor or Integer.valueOf(), Java handles this for you automatically.

Example:

public class AutoboxingExample {
    public static void main(String[] args) {
        int num = 50;                 // Primitive int
        Integer obj = num;           // Autoboxing happens here

        System.out.println("Primitive int: " + num);
        System.out.println("Wrapper Integer: " + obj);
    }
}

👉 Explanation :

• num is a primitive int with value 50.
• When assigning num to obj of type Integer, Java automatically converts the primitive num into an Integer object.

⚡Behind the scenes, the compiler effectively does:

Integer obj = Integer.valueOf(num);

✅ Why Is Autoboxing Useful?

• It simplifies code readability by removing the need for explicit conversions.
• Makes it easier to work with Java Collections (like ArrayList<Integer>) that only accept objects.
• Prevents boilerplate code, keeping programs clean and concise.

⚠️ Important Note

While autoboxing is convenient, be cautious when using it in performance-critical applications, especially in loops. Unnecessary creation of objects may increase memory usage and affect performance

🚀 Autoboxing makes primitive and object interaction effortless, contributing to cleaner and easier-to-read Java code

3.2 Unboxing

In Java, Unboxing is the automatic conversion of a Wrapper class object (like Integer, Double, Boolean) back into its corresponding primitive type (int, double, boolean).

This happens automatically when a wrapper object is used in a context where a primitive type is expected. The compiler takes care of extracting the primitive value from the object, so you don’t have to call methods like .intValue() explicitly.

⚡ How Does It Work?

Imagine you have an Integer object that holds the value 100. If you want to use this value in arithmetic calculations or any place where a primitive int is needed, Java will automatically extract the primitive value from the wrapper object.

Example:

public class UnboxingExample {
    public static void main(String[] args) {
        Integer obj = Integer.valueOf(100);   // Wrapper Integer object

        int num = obj;  // Unboxing happens here: Integer → int

        System.out.println("Wrapper Integer: " + obj);
        System.out.println("Primitive int: " + num);
    }
}

👉 What happens here:

• obj is an Integer object storing the value 100.
• When we assign obj to num, Java automatically performs unboxing, converting the object into the primitive int value.

⚡ Behind the scenes, the compiler effectively does:

int num = obj.intValue();

✅ Why Is Unboxing Useful?

• Simplifies code readability by avoiding explicit method calls like .intValue().
• Makes arithmetic operations easy: you can use wrapper objects directly in expressions.
• Supports seamless interaction between object-oriented APIs and primitive types.

⚠️ Important Consideration:
Beware of null pointer exceptions when unboxing.
If the wrapper object is null, unboxing it will throw a NullPointerException:

Integer obj = null;
int num = obj;  // Throws NullPointerException!

🚀 Unboxing helps Java handle the transition from objects to primitive types automatically, making code easier to write and read, while keeping object-oriented benefits intact.

4️⃣Converting Wrapper Class to Primitive Type

A Wrapper Class (such as Integer, Double, or Boolean) wraps a primitive type into an object. However, sometimes you need to extract the primitive value from the wrapper object, for example, when performing arithmetic operations or passing values to methods that require primitives.

⚡ How to Convert Wrapper Class to Primitive Type

You can explicitly convert a wrapper object to its primitive type by using methods provided by the wrapper classes:

These methods return the underlying primitive value stored in the wrapper object.

✅ Example:

Use methods like intValue(), doubleValue(), booleanValue() to extract the primitive value from a wrapper object.

Example:

public class WrapperToPrimitive {
    public static void main(String[] args) {
        Integer intObj = 123;               // Integer wrapper object
        int num = intObj.intValue();       // Extract int value

        Double doubleObj = 45.67;          // Double wrapper object
        double d = doubleObj.doubleValue(); // Extract double value

        Boolean boolObj = true;            // Boolean wrapper object
        boolean flag = boolObj.booleanValue(); // Extract boolean value

        System.out.println("int: " + num);
        System.out.println("double: " + d);
        System.out.println("boolean: " + flag);
    }
}

👉 In this example:

• intObj.intValue() extracts the primitive int from the Integer object.
• doubleObj.doubleValue() extracts the primitive double.
• boolObj.booleanValue() extracts the primitive boolean.

✅ When Is This Useful?

• When working in older Java versions (before autoboxing/unboxing was introduced).
• When you want to explicitly extract a primitive value to avoid any confusion.
• When working with APIs that require primitive arguments.

⚠️ Important Note:
If the wrapper object is null, calling .intValue(), .doubleValue(), or .booleanValue() will throw a NullPointerException.

Example of what to avoid:

Integer obj = null;
int num = obj.intValue();  // Throws NullPointerException!

🚀 Explicit conversion from a Wrapper Class to its primitive type gives you full control and ensures that your program behaves predictably when mixing objects and primitives.

5️⃣Converting Primitive Type to Wrapper Class

In Java, Wrapper Classes provide an object representation of primitive types like int, double, or boolean. Sometimes, it is necessary to convert primitive types into their corresponding wrapper objects explicitly, especially when working with collections such as ArrayList, or when an API requires an object type.

⚡ How Does This Conversion Work?

There are two main approaches to convert a primitive type into its corresponding Wrapper Class object:

1. Using valueOf() Method (Recommended)
   • This is the preferred way because it may cache frequently used values (e.g., small integers), which improves performance.
2. Using Wrapper Class Constructor (Deprecated in some versions)
   • Example: new Integer(10) works but is discouraged in favor of Integer.valueOf(10).

Example:

public class PrimitiveToWrapper {
    public static void main(String[] args) {
        int num = 10;
        Integer intObj = Integer.valueOf(num);  // Converts int → Integer

        double d = 99.99;
        Double doubleObj = Double.valueOf(d);  // Converts double → Double

        boolean flag = false;
        Boolean boolObj = Boolean.valueOf(flag);  // Converts boolean → Boolean

        System.out.println("Integer Object: " + intObj);
        System.out.println("Double Object: " + doubleObj);
        System.out.println("Boolean Object: " + boolObj);
    }
}

👉 In this example:

• Integer.valueOf(num) converts the primitive int num = 10 into an Integer object.
• Double.valueOf(d) converts the primitive double d = 99.99 into a Double object.
• Boolean.valueOf(flag) converts the primitive boolean flag = false into a Boolean object.

✅ Why Use valueOf() Instead of Constructors?

• Performance Benefits: The valueOf() method can cache common values, such as integers from -128 to 127, which reduces memory usage and improves performance.
• Best Practice: Using valueOf() is now preferred over using constructors like new Integer(num).

Example :

Integer a = Integer.valueOf(100);
Integer b = Integer.valueOf(100);
System.out.println(a == b);  // true, because of caching

Integer x = Integer.valueOf(200);
Integer y = Integer.valueOf(200);
System.out.println(x == y);  // false, because 200 is outside cache range

✅ When Is Conversion Needed?

• Adding numbers to a collection like ArrayList<Integer>:
• Passing objects where APIs expect a Number, Object, or other wrapper type.

<code>ArrayList<Integer> numbers = new ArrayList<>(); int primitiveNum = 5; numbers.add(Integer.valueOf(primitiveNum)); // Explicit conversion</code>

⚠️ Important Note:
Thanks to Autoboxing, explicit calls to valueOf() are often unnecessary in modern Java. The compiler automatically converts primitive types to their wrapper equivalents when needed.

Example with Autoboxing:

Integer intObj = 10;  // Autoboxing automatically calls Integer.valueOf(10)

However, understanding explicit conversion is useful for clarity, performance considerations, and when reading legacy code.

🚀 Converting primitive types to Wrapper Classes allows you to take advantage of Java’s object-oriented features while working safely and efficiently with APIs that require objects.

6️⃣ Usage of Wrapper Classes

Wrapper classes in Java play a crucial role whenever we need to treat primitive types as objects. Here are two of the most important real-world use cases for Wrapper Classes explained in detail.

➔ 6.1 Working with Collections (e.g., ArrayList)

Java Collections (like ArrayList, HashMap, etc.) work with objects only, not primitive types. Since primitives such as int, double, and boolean are not objects, we use their corresponding Wrapper Classes (Integer, Double, Boolean) when storing them in collections.

✅ Example: Storing Integers in an ArrayList

import java.util.ArrayList;

public class WrapperWithCollection {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();

        // Autoboxing automatically converts primitives to wrapper objects
        numbers.add(10);  // int → Integer
        numbers.add(20);

        // When retrieving elements, unboxing happens automatically
        int sum = numbers.get(0) + numbers.get(1);

        System.out.println("Sum: " + sum);  // Output: Sum: 30
    }
}

👉 How It Works:

• numbers.add(10); → The primitive int value 10 is autoboxed to an Integer object and stored in the ArrayList.
• numbers.get(0) → Retrieves an Integer object, which is unboxed back to a primitive int when used in arithmetic.

✅ Why Is This Important?

• Collections work with objects, so Wrapper Classes allow primitives to fit in.
• Autoboxing and Unboxing simplify the code by handling conversions automatically.
• Avoids manually creating objects like new Integer(10).

➔ 6.2 Parsing Strings to Primitive Types

When working with user input or data from external sources (e.g., files, APIs), values are often in String form. To use these values in calculations, they must be converted into primitive types.

✅ Example: Converting String to Primitives

public class StringToPrimitive {
    public static void main(String[] args) {
        String strInt = "100";
        int num = Integer.parseInt(strInt);  // Converts String → int

        String strDouble = "99.99";
        double d = Double.parseDouble(strDouble);  // Converts String → double

        System.out.println("Parsed int: " + num);      // Output: Parsed int: 100
        System.out.println("Parsed double: " + d);    // Output: Parsed double: 99.99
    }
}

👉 How It Works:

• Integer.parseInt(strInt) converts a numeric string into a primitive int.
• Double.parseDouble(strDouble) converts a string representing a decimal into a primitive double.

✅ Why Is This Useful?

• Essential for applications that receive numeric input as strings (e.g., user input forms).
• Prevents manual parsing or errors by using built-in utility methods.
• Works reliably and efficiently, ensuring type safety.

🚀 By using Wrapper Classes, Java bridges the gap between primitive types and objects, enabling powerful functionality while maintaining simplicity through autoboxing and unboxing.

7️⃣Summary Table of Common Wrapper Class Methods

🎯 Conclusion

Wrapper Classes are powerful tools in Java that bridge the gap between primitive types and objects. They enable convenient operations such as collection storage, type conversion, and utility functions. Autoboxing and unboxing make it seamless to switch between primitive types and their wrappers without explicit conversions in most cases.