Wrapper Classes in Java | Use, Example

A class that wraps a primitive data type into an object is called wrapper class in java.

In simple words, wrapper class provides a mechanism to convert primitive data type value into an object and vice-versa.

For example, wrapping int into Integer class, wrapping double into Double class, and wrapping char into Character class.

When we create an object of wrapper class, it contains a variable where we store the primitive data type value. In simple words, we can wrap a primitive type value into a wrapper class object.

For example, if we create an object of Integer wrapper class, it contains a single variable (or field) that will store an int value like 25, as shown in the below figure. Thus, Integer is a wrapper class of int data type.

Wrapper classes in Java

Code for Wrapping and Unwrapping an int value

Wrapping an int value:

int x = 25;
Integer iWrap = new Integer(x); // Pass the primitive type to the wrapper constructor.

Unwrapping an int value:

int unWrapped = iWrap.intValue();

Why we need or use wrapper classes in Java?

There are several reasons to use wrapper classes in java that are as follows:

1. We have seen several applications on the Internet that receive data from the user and send it to the server. For example, in a business application like Amazon, we enter our details like name, debit or credit card number, address, phone number, etc at the time of purchasing anything.

All these data are sent to the server. The server expects these data in the form of objects. In our data,” ‘name’ is a String type object, but debit card number is an int type value, that is not an object.


This primitive data type value must be converted into an object before being sent to the server. To overcome this conversion, we need wrapper classes in java.

A wrapper class contains a variable that stores the primitive data type value. When we create an object of a wrapper class, it carries the primitive data type value within it.

The object then is sent to the server. The server retrieves the primitive type value from the object and uses it.

2. In Java, collection classes (ArrayList, LinkedList, Vector, HashSet, LinkedHashSet, TreeSet, PriorityQueue, ArrayDeque, etc.) of Java collections framework are defined in java.util package which stores only objects, not primitive type values.

If we want to use collection classes on primitive type values, we should convert them into objects.

For example, we cannot directly store primitive data types in an ArrayList because elements in an ArrayList must be objects.

There is no such thing as “ArrayList<double>”. Here, double is a primitive data type but it is not an object. Therefore, ArrayList<double> will not compile.

To convert primitive type values into objects, the Java platform includes wrapper classes in the Java API. It provides a convenient way to incorporate or wrap a primitive data type into an object.

3. Java synchronization works with objects in Multithreading.

4. Since Java supports only call by value, therefore, if we pass a primitive value, it will not change the original value.

But, if we want to change the original value, we need to convert the primitive type value into an object that can be done using the wrapper class.

5. To perform serialization in java, we need to convert objects into streams. If we have a primitive value, we can convert it into objects with the help of java wrapper classes.

6. There are several utility classes defined in java.util package that deals with objects.

Note: Java 5.0 version introduced two important new features autoboxing and unboxing that convert primitive data type values into objects and objects into primitive data type values automatically.

The process of automatic conversion of primitive data type into an object is known as autoboxing and vice versa unboxing.

Look at the source code and see how auto boxing and unboxing are automatically done by java compiler when we want to make an ArrayList to hold int value.

// With autoboxing (Java versions 5.0 or greater)
   ArrayList<Integer> ar = new ArrayList<Integer>(); // Making an ArrayList of type Integer.
    ar.add(3);
    int num = ar.get(0);

List of Wrapper classes in Java

Java platform provides the list of eight wrapper classes for each of the primitive types. These wrapper classes are defined in java.lang package.


All the java wrapper classes are immutable and final whose objects each hold a single primitive value. Immutable means once objects are created, their internal values cannot be changed. Methods of wrapper classes are implicitly final and may not be overridden.

They are useful to convert primitive data types into object forms. They are listed in the table below:

Table: Primitive Date types and their Corresponding Wrapper classes

Primitive Data typeCorresponding Wrapper class
charCharacter
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
booleanBoolean

Naming convention: Names of the java wrapper class start with uppercase letters. Most wrapper class names are the same as primitive data type names, except Integer and Character.

The object of the Boolean class wraps the Boolean value true or false. To store double values in an ArrayList, we use an ArrayList<Double>.

Wrapper Classes Example Programs

1. Let’s take an example program where we will convert a primitive data type int value into an Integer object explicitly. Java compiler will also convert automatically from int to Integer. This is called autoboxing. Look at the source code to understand better.

Program code 1:

public class Wrapping {
public static void main(String[] args) 
{	
  int a = 50; // Primitive data type value.

 Integer i = Integer.valueOf(a); // Here, we are converting int into Integer explicitly.  
 Integer j = a; // Here, Autoboxing is happening. Java compiler will write Integer.valueOf(a) internally.  
	  
 System.out.println(a+" "+i+" "+j);
   }
}
Output:
      50 50 50

The valueOf() method of Integer class is used to int number into Integer object. The return type of this method is object. This method is static in nature. Therefore, we call it using its class name.

2. We can also convert from Integer to int explicitly and implicitly by the compiler. Let’s write code for it.

Program code 2:

public class Unwrapping {
public static void main(String[] args) 
{	
// For converting Integer to int, create an object of Integer class and pass the value to its constructor. 
  Integer a = new Integer(50);    
	
  int i = a.intValue();// Here, we are converting Integer to int explicitly.   
  int j = a; // Unboxing is happening. Java compiler will write a.intValue() internally.    
	    
  System.out.println(a+" "+i+" "+j); 
   }
}
Output:
      50 50 50

The intValue() method of Integer class is used to convert Integer object into a primitive int type value. This is called unboxing. The return type of this method is int.

Program code 3:

public class WrappingUnwrapping {
public static void main(String[] args) 
{ 
 char ch = 'a'; // char data type.
 Character chrobj = new Character(ch);	// Wrapping char type value into Character object.
 
 byte a = 10; // byte data type value.
 Byte byteobj = new Byte(a); // Wrapping byte type value into Byte object.

 int b = 20; // int type value.
 Integer intobj = new Integer(b); // Wrapping int type value into Integer object.

 float c = 18.6f; // float type value.
 Float floatobj = new Float(c); // Wrapping float type value into Float object.

 double d = 250.5; // double data type value. 
 Double doubleobj = new Double(d); // Wrapping double data type value into Double object.

// Displaying the values from wrapper class objects. 
  System.out.println("Displaying values of Wrapper class objects:"); 
  System.out.println("Character object:  " + chrobj); 
  
  System.out.println("Byte object:  " + byteobj); 
  System.out.println("Integer object:  " + intobj); 
  
  System.out.println("Float object:  " + floatobj); 
  System.out.println("Double object:  " + doubleobj); 
    
     System.out.println("\n");
// Retrieving primitive data type values from objects. 
// Unwrapping objects to primitive data type values.
    char chr = chrobj;
    byte by = byteobj; 
    int in = intobj; 
    float fl = floatobj; 
    double db = doubleobj; 
     
// Displaying the values of data types. 
  System.out.println("Displaying unwrapped values: ");
  
  System.out.println("char value: " + chr);
  System.out.println("byte value: " + by); 
  
  System.out.println("int value: " + in); 
  System.out.println("float value: " + fl); 
  System.out.println("double value: " + db); 
  }
}
Output:
      Displaying values of Wrapper class objects:
      Character object:  a
      Byte object:  10
      Integer object:  20
      Float object:  18.6
      Double object:  250.5

      Displaying unwrapped values: 
      char value: a
      byte value: 10
      int value: 20
      float value: 18.6
      double value: 250.5

Key Points:

1. Wrapper class in Java provides several constructors, constants, and conversion methods for manipulating various primitive data type values.

2. Wrapper classes have no no-arg constructors.

3. Character class does not have a constructor with String as a parameter.

4. The instances of all wrapper classes are immutable and final. That means once the object is created, its internal value cannot be changed.

Hope that this tutorial has covered important points related to wrapper classes in java with example programs. I hope that you will have understood this topic and enjoyed it.

If you find anything incorrect in this tutorial, then please inform our team via email. Your email will be precious to us.
Thanks for reading!!!!
Next ⇒ Java Number Class

⇐ Prev Next ⇒

Please share your love