Java wrapper classes – autoboxing, unboxing and conversion examples

Learn about Java wrapper classes, their usage, conversion between primitive and object; and autoboxing and unboxing with examples.

1. Java Wrapper classes

Java provides type wrappers, which are classes that encapsulate a primitive type within an object. In Java, we have 8 primitive data types.

A wrapper class wraps (encloses) around a data type and gives it an object appearance. Wherever, the data type is required as an object, this object can be used. Wrapper classes include methods to unwrap the object and give back the data type.

The type wrappers classes are part of java.lang package.

Each primitive type has a corresponding wrapper class.

2. When to use wrapper classes

Java wrapper classes are used in scenarios –

• When two methods wants to refer to the same instance of an primitive type, then pass wrapper class as method argument.
• Generics in Java works only with object and does not support primitive types.
• Collections in Java deal only with objects; to store a primitive type in one of these classes, you need to wrap the primitive type in a class.
• When you want to refer null from data type, the you need object. Primitives cannot have null as value.

3. Conversion

3.1. Primitive type to wrapper class

There are two ways for converting a primitive type into an object of corresponding wrapper class –

1. using constrcutors
2. using static factory methods such as valueOf() (except Character)

// 1. using constructor
Integer object = new Integer(10);

// 2. using static factory method
Integer anotherObject = Integer.valueOf(10);

In above example, the valueOf() method returns an instance representing the specified int value.

Similarly, we can convert other primitive types like boolean to Boolean, char to Character, short to Short, etc.

Java wrapper classes uses internal caching which returns cached values which makes it efficient and memory wise.

3.2. Wrapper class to primitive type

Converting from wrapper to primitive type is simple. We can use the corresponding methods to get the primitive type. e.g. intValue(), doubleValue(), shortValue() etc.

Integer object = new Integer(10);

int val = object.intValue();	//wrapper to primitive

4. Autoboxing and Unboxing

Beginning with JDK 5, Java added two important features: autoboxing and auto-unboxing.

4.1. Autoboxing

Autoboxing is the automatic conversion of the primitive types into their corresponding object wrapper classes. For example, converting an int to an Integer, a char to a Character, and so on.

We can simply pass or assign a primitive type to an argument or reference accepting wrapper class object. e.g.

Character ch = 'a';		//char to Character

List<Integer> integerList = new ArrayList<>();

for (int i = 1; i < 10; i ++) 
{
    integerList.add(i);		//int to Integer
}

integerList is a list of Integer objects, not a list of primitive type int values. Compiler automatically creates an Integer object from i and adds the object to integerList. Thus, the previous code turn into the following at runtime:

List<Integer> integerList = new ArrayList<>();

for (int i = 1; i < 50; i += 2) 
{
    integerList.add(Integer.valueOf(i));		//autoboxing
}

4.2. Unboxing

Unboxing happens when the conversion happens from wrapper class to its corresponding primitive type. It means we can pass or assign a wrapper object to an argument or reference accepting primitive type. e.g.

public static int sumOfEven(List<Integer> integerList) 
{
    int sum = 0;
    for (Integer i: integerList) {
    	if (i % 2 == 0)
            sum += i;			//Integer to int
    }
    return sum;
}

In above example, the remainder (%) and unary plus (+=) operators does not apply on Integer objects. The compiler automatically converts an Integer to an int at runtime by invoking the intValue() method.

Autoboxing and unboxing lets developers write cleaner code, make it easier to read.

Happy Learning !!

Read More:

SO Thread