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).
| Primitive Type | Corresponding Wrapper Class |
|---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
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 :
numis a primitiveintwith value50.- When assigning
numtoobjof typeInteger, Java automatically converts the primitivenuminto anIntegerobject.
⚡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:
objis anIntegerobject storing the value100.- When we assign
objtonum, Java automatically performs unboxing, converting the object into the primitiveintvalue.
⚡ 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:
| Wrapper Class | Method Example |
|---|---|
Integer | .intValue() |
Double | .doubleValue() |
Boolean | .booleanValue() |
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 primitiveintfrom theIntegerobject.doubleObj.doubleValue()extracts the primitivedouble.boolObj.booleanValue()extracts the primitiveboolean.
✅ 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:
- Using
valueOf()Method (Recommended)- This is the preferred way because it may cache frequently used values (e.g., small integers), which improves performance.
- Using Wrapper Class Constructor (Deprecated in some versions)
- Example:
new Integer(10)works but is discouraged in favor ofInteger.valueOf(10).
- Example:
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 primitiveint num = 10into anIntegerobject.Double.valueOf(d)converts the primitivedouble d = 99.99into aDoubleobject.Boolean.valueOf(flag)converts the primitiveboolean flag = falseinto aBooleanobject.
✅ Why Use valueOf() Instead of Constructors?
- Performance Benefits: The
valueOf()method can cache common values, such as integers from-128to127, which reduces memory usage and improves performance.- Best Practice: Using
valueOf()is now preferred over using constructors likenew 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 primitiveintvalue10is autoboxed to anIntegerobject and stored in theArrayList.numbers.get(0)→ Retrieves anIntegerobject, which is unboxed back to a primitiveintwhen 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 primitiveint.Double.parseDouble(strDouble)converts a string representing a decimal into a primitivedouble.
✅ 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
| Wrapper Class | Method Example | Purpose |
|---|---|---|
Integer | Integer.parseInt("123") | Convert String to int |
Double | Double.valueOf(3.14) | Convert double primitive to Double object |
Boolean | Boolean.parseBoolean("true") | Convert String to boolean |
Character | Character.toUpperCase('a') | Character manipulation utility |
🎯 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.
