Wrapper Class in Java – Implement Autoboxing and Unboxing with Examples
Get Job-ready: Java Course with 45+ Real-time Projects! - Learn Java
In programs, you must have come across terms like “Integer.parseInt()” and Character.getNumericValue(). Well, these are wrapper classes and simply help to convert primitive data types into Objects. Why objects? Because we need to modify datatypes during programming and objects are useful for doing manipulations. We will also learn about how primitive data types are converted to Wrapper Classes and so on. Let us start!
Wrapper Class in Java
Wrapper classes, as the name suggests, wraps around or encapsulates primitive datatypes in Java. We talked about this in one of our previous articles so be sure to check them out too.
Wrapper classes, simply put, is basically a class for converting a primitive datatype, to an object for specific functions. This is useful because primitive datatypes are generally immutable. Also, in Java, everything is object-oriented in nature. So if you want to have a deeper understanding of how this work, read along.
Some of the main reasons why wrapper classes are essential in programming are as follows:
- When we are working with methods, it is essential that the arguments we pass to them are objects and not primitive values. Hence wrapper classes help by converting the primitive datatype into its specific Wrapper class.
- All classes in java.util package work with objects. Hence if we need to use these classes we need to convert primitive data types to Wrapper class objects.
- All collections, such as ArrayLists and Queues work with Objects as input. It is easy if the objects are of a user-defined datatype. But if they are primitive datatypes they cannot directly be stored in the collection. Hence we need to box them into objects and then use them accordingly.
- Objects are essential for supporting synchronization in multithreading.
- If we want to implement serialization in Java, we can only do so with the help of objects. That is why primitive data types need to be converted to objects.
Table of java Wrapper Classes with their Respective Primitive Classes
Primitive Datatypes | Wrapper Classes |
byte | Byte |
boolean | Boolean |
char | Character |
int | Integer |
long | Long |
short | Short |
double | Double |
float | Float |
Autoboxing in Java
Autoboxing is the process of converting a primitive datatype to its corresponding Wrapper class. You should know that this process is automatic and takes place whenever a method gets a primitive datatype as its argument where it expects an object. This may sound complex at first but trust me, it will get very easy to understand if you look at some of the examples.
If you have seen lists, you must know about ArrayLists in Java. So the ArrayLists take an object as an input to its add() function. The syntax is:
<list_name>.add(<Object of type of ArrayList>)
Now, whenever you add an integer element to a list, it automatically converts it to a respective Integer wrapper class. The object can then prove to be fruitful to the function.
Java Program to Illustrate Autoboxing
package com.dataflair.wrapperclass; import java.util.ArrayList; import java.util.List; import org.w3c.dom.TypeInfo; public class Autoboxing { public static void main(String[] args) { List<Integer> list = new ArrayList<>(); int a=3; //System.out.println(a.getClass()); This will result in an error because int is not an object. list.add(3);// Here the value 3 is primitive but converted to Wrapper class Integer list.add(4); System.out.println(list.get(0).getClass()); System.out.println(list.toString()); } }
Output
[3, 4]
Do remove the comment at line 10 and see what error arises for yourself.
Unboxing in Java
Unboxing is the inverse of Autoboxing. It is the process of converting a Wrapper class object into its corresponding Primitive Datatype. For instance, an Integer object would be converted to a primitive data type, i.e, int.
Java Program to Illustrate Unboxing in Java
package com.dataflair.wrapperclass; public class Unboxing { public static void main(String[] args) { Integer wrapperInteger = new Integer(4); wrapperInteger.getClass(); int a=wrapperInteger;//Unboxing System.out.println(a); //a.getClass(); This would result in an error because it is a primitive datatype. } }
Output
Custom Wrapper Classes in Java
Right now, you may be thinking, “Can I have my own Wrapper Class in Java?” and the answer is yes. You can. In java, you can create custom wrapper classes for yourself. However, this is similar to declaring a class for a datatype. Let us look at an example below.
Program to Illustrate the use of Custom Wrappers in Java
package com.dataflair.wrapperclass; public class CustomWrapper { int i; CustomWrapper() { System.out.println("This is a custom wrapper class"); } CustomWrapper(int num) { this(); this.i=num; } public int getI() { return i; } public static void main(String[] args) { CustomWrapper custom=new CustomWrapper(54); System.out.println(custom.getClass()); } }
Output
class CustomWrapper
As you can see, this is very easy to understand and grasp. More practice will give you a deeper understanding of Wrapper classes in java.
Advantages of Wrapper Classes
- The primary advantage of Wrapper Classes is that we need Wrapper objects to function with collections which is only possible with the help of Wrapper classes.
- As the wrapper classes have objects we can store null as a value. We could not store null in variables of primitive datatype.
One important point to note is that primitive datatypes are more efficient than wrapper class objects and it is essential to know when to use which.
Summary
In Java, wrapper classes form the base of all method invocations. It also allows Java to manipulate primitive data types without changing their actual values. A strong concept of these topics would surely benefit you a lot in your development journey.
Did you know we work 24x7 to provide you best tutorials
Please encourage us - write a review on Google
this is beautifull