Wrapper classes in Java are used to represent primitive data types as objects. They provide a way to work with primitive data types in a more object-oriented manner, and they are especially useful when you need to pass primitive values as objects or when you want to use certain methods provided by these classes.
Here are the primitive data types and their corresponding wrapper classes in Java:
byte – Byteshort – Shortint – Integerlong – Longfloat – Floatdouble – Doublechar – Characterboolean – BooleanHere’s an example of using wrapper classes in Java:
public class WrapperClassesExample {
public static void main(String[] args) {
// Using Integer wrapper class
Integer intObj = new Integer(42); // Creating an Integer object
int primitiveInt = intObj.intValue(); // Converting Integer to int
System.out.println("Primitive int: " + primitiveInt);
// Using Double wrapper class
Double doubleObj = new Double(3.14159); // Creating a Double object
double primitiveDouble = doubleObj.doubleValue(); // Converting Double to double
System.out.println("Primitive double: " + primitiveDouble);
// Autoboxing and Unboxing (Java automatically converts between primitive and wrapper)
Integer autoboxedInt = 100; // Autoboxing (int to Integer)
int unboxedInt = autoboxedInt; // Unboxing (Integer to int)
System.out.println("Autoboxed and Unboxed int: " + unboxedInt);
// Using Boolean wrapper class
Boolean boolObj = new Boolean(true); // Creating a Boolean object
boolean primitiveBool = boolObj.booleanValue(); // Converting Boolean to boolean
System.out.println("Primitive boolean: " + primitiveBool);
// Using Character wrapper class
Character charObj = new Character('A'); // Creating a Character object
char primitiveChar = charObj.charValue(); // Converting Character to char
System.out.println("Primitive char: " + primitiveChar);
}
}
In above example, we create objects of various wrapper classes, convert them back to their corresponding primitive types, and demonstrate autoboxing and unboxing. Autoboxing allows you to assign primitive values directly to wrapper objects, and unboxing allows you to retrieve primitive values from wrapper objects.
Wrapper classes are particularly useful when you need to work with collections like ArrayList or HashMap, which can only store objects, not primitives. They also provide helpful methods for converting, parsing, and manipulating primitive values as objects.
For instance, the Java Collection Framework exclusively deals with objects. In the past, before the introduction of autoboxing (prior to Java 5), we couldn’t directly add a primitive value like ‘125‘ to a collection of Integers. During that era, we had to manually convert these primitive values into their corresponding wrapper classes and then store them in collections.
Today, thanks to autoboxing, we can effortlessly use ArrayList.add(125). However, under the hood, Java automatically converts the primitive value into an Integer using the valueOf() method before storing it in the ArrayList.
In Java, you can convert a primitive data type to its corresponding wrapper class using a process called “boxing” or “autoboxing.” Autoboxing is a feature introduced in Java 5 that allows automatic conversion between primitive types and their wrapper classes. Here’s how you can perform primitive to wrapper class conversion in Java:
1. Using Autoboxing (Automatic Conversion): Autoboxing allows you to convert a primitive type to its wrapper class automatically when needed. For example:
In this example, the int value 42 is automatically converted to an Integer object.
int primitiveInt = 42;
Integer wrapperInt = primitiveInt; // Autoboxing
2. Using Constructor or ValueOf Method (Manual Conversion): You can also perform manual conversion by using the constructor of the wrapper class or the valueOf() method. Here’s an example: Both of these methods explicitly create an Integer object from the int value.
int primitiveInt = 42;
Integer wrapperInt = new Integer(primitiveInt); // Using constructor
// OR
Integer wrapperInt2 = Integer.valueOf(primitiveInt); // Using valueOf method
3. For Other Primitive Types: Similar conversions can be performed for other primitive data types and their corresponding wrapper classes, such as char to Character, float to Float, double to Double, etc. Here are some examples for other primitive types:
char primitiveChar = 'A';
Character wrapperChar = primitiveChar; // Autoboxing
float primitiveFloat = 3.14f;
Float wrapperFloat = primitiveFloat; // Autoboxing
Converting from a wrapper class to a primitive type is called “unboxing,” and it can also be done automatically (autounboxing) or manually using methods like intValue(), doubleValue(), floatValue(), etc., depending on the specific wrapper class and primitive type.
It’s important to note that autoboxing and unboxing can make your code more concise and readable, but you should be aware of potential performance implications in certain situations, as creating objects (wrapper classes) can have a slight overhead compared to working directly with primitive types.