Wrapper classes in Java

The wrapper class in Java offers the mechanism to translate primitive into object and object into primitive. This feature has obtained from Java J2SE 5.0, autoboxing and unboxing. Actually, these feature convert primitives into objects and objects into primitives automatically. The automatic conversion of primitive into an object is known as autoboxing and unboxing. Wrapper class is a class whose object wraps or contains primitive data types.

In more details:

When create an object to a wrapper class, it contains a field and, in this field, there can store primitive data types. In other words, wrap a primitive value into a wrapper class object.

Necessity of Wrapper Classes,

• These classes convert primitive data types into objects.
• Objects are needed if we wish to modify the arguments passed into a method (because primitive types are passed by value).
• The classes in java.util package handles only objects and hence wrapper classes help in this scenario.
• Data structures in the Collection framework, such as ArrayList and Vector, store only objects (reference types) and not primitive types.
• An object is needed to support synchronization in multithreading.

Use of Wrapper classes in Java

As Java is an object-oriented programming language(OOP), need to deal with objects many times such as in Collections, Serialization, Synchronization, etc. To use the wrapper classes need

• Change the value in Method: Java supports only call by value. So, if we pass a primitive value, it will not change the original value. But, if we convert the primitive value in an object, it will change the original value.
• Serialization: We need to convert the objects into streams to perform the serialization. If we have a primitive value, we can convert it in objects through the wrapper classes.
• Synchronization: Java synchronization works with objects in Multithreading.
• util package: The java.util package provides the utility classes to deal with objects.
• Collection Framework: Java collection framework works with objects only. All classes of the collection framework (ArrayList, LinkedList, Vector, HashSet, LinkedHashSet, TreeSet, PriorityQueue, ArrayDeque, etc.) deal with objects only.

The eight classes of the java.lang package are known as wrapper classes in Java. The list of eight wrapper classes are given below:

Autoboxing

The automatic alteration of primitive data type into its equivalent wrapper class is known as autoboxing, for instance, byte to Byte, char to Character, int to Integer, long to Long, float to Float, boolean to Boolean, double to Double, and short to Short.

Wrapper class Example: Primitive to Wrapper

//Java program to convert primitive into objects 

//Autoboxing example of int to Integer 

public class WrapperExample{ 

public static void main(String args[]){ 

//Converting int into Integer 

int a=10; 

Integer i=Integer.valueOf(a);//converting int into Integer explicitly 

Integer j=a;//autoboxing, now compiler will write Integer.valueOf(a) internally 

System.out.println(a+" "+i+" "+j); 

}
} 

Output:

20 20 20

Unboxing

The automatic conversion of wrapper type into its corresponding primitive type is known as unboxing. It is the reverse process of autoboxing. Since Java 5, we do not need to use the intValue() method of wrapper classes to convert the wrapper type into primitives. Wrapper class Example: Wrapper to Primitive

//Java program to convert primitive into objects (Autoboxing example of int to Integer) 
public class WrapperExample{  
public static void main(String args[])
{  
//Converting int into Integer  
int a=10;  
Integer i=Integer.valueOf(a);//converting int into Integer explicitly  
Integer j=a;//autoboxing, now compiler will write Integer.valueOf(a) internally  
System.out.println(a+" "+i+" "+j);  
}
}  

Output:

3 3 3

Java Wrapper classes Example

//Java Program to convert all primitives into its corresponding wrapper objects

public class WrapperExample{ 

public static void main(String args[]){ 

byte b=100; 

short s=200; 

int i=300; 

long l=400; 

float f=500.0F; 

double d=600.0D; 

char c='a'; 

boolean b2=true; 




//Autoboxing: Converting primitives into objects 

Byte byteobj=b; 

Short shortobj=s; 

Integer intobj=i; 

Long longobj=l; 

Float floatobj=f; 

Double doubleobj=d; 

Character charobj=c; 

Boolean boolobj=b2; 




//Printing objects 

System.out.println("Show values"); 

System.out.println("Byte object: "+byteobj); 

System.out.println("Short object: "+shortobj); 

System.out.println("Integer object: "+intobj); 

System.out.println("Long object: "+longobj); 

System.out.println("Float object: "+floatobj); 

System.out.println("Double object: "+doubleobj); 

System.out.println("Character object: "+charobj); 

System.out.println("Boolean object: "+boolobj); 




//Unboxing: Converting Objects to Primitives 

byte bytevalue=byteobj; 

short shortvalue=shortobj; 

int intvalue=intobj; 

long longvalue=longobj; 

float floatvalue=floatobj; 

double doublevalue=doubleobj; 

char charvalue=charobj; 

boolean boolvalue=boolobj; 




//Printing primitives 

System.out.println(" Show primitive values"); 

System.out.println("byte value: "+bytevalue); 

System.out.println("short value: "+shortvalue); 

System.out.println("int value: "+intvalue); 

System.out.println("long value: "+longvalue); 

System.out.println("float value: "+floatvalue); 

System.out.println("double value: "+doublevalue); 

System.out.println("char value: "+charvalue); 

System.out.println("boolean value: "+boolvalue); 

}}

Output:

Show object values

Byte object: 100

Short object: 200

Integer object: 300

Long object: 400

Float object: 500.0

Double object: 600.0

Character object: a

Boolean object: true

Show primitive values

byte value: 100

short value: 200

int value: 300

long value: 400

float value: 500.0

double value: 600.0

char value: a

boolean value: true

Custom Wrapper class in Java

Java Wrapper classes wrap the primitive data types, that is why it is known as wrapper classes. We can also create a class which wraps a primitive data type. So, we can create a custom wrapper class in Java.

//Creating the custom wrapper class 

class WrapperExample { 

private int i; 

WrapperExample (){} 

WrapperExample (int i){  

this.i=i; 

} 

public int getValue(){ 

return i; 

} 

public void setValue(int i){ 

this.i=i; 

} 

@Override 

public String toString() { 

  return Integer.toString(i); 

} 

} 

//Test the custom wrapper class 

public class TestWrapperExample { 

public static void main(String[] args){ 

WrapperExample j=new WrapperExample (10); 

System.out.println(j); 
}

Output:

10