2.1) Creating objects of the wrapper classes

1)Class hierarchy of wrapper classes:

All the wrapper classes implement the interfaces java.io.Serializable and java.lang.Comparable. All these classes can be serialized to a stream, and their objects define a natural sort order.

2) Creating objects of the wrapper classes:

You can create objects of all the wrapper classes in multiple ways:

• Assignment—By assigning a primitive to a wrapper class variable

• Constructor—By using wrapper class constructors

• Static methods—By calling the static method of wrapper classes, like valueOf()

You can create objects of the rest of the wrapper classes (Short, Integer, Long, and Float) in a similar manner. All the wrapper classes define constructors to create an object using a corresponding primitive value or as a String.

Another interesting point to note is that neither of these classes defines a default no-argument constructor. Because wrapper classes are immutable, it doesn’t make sense to initialize the wrapper objects with the default primitive values if they can’t be modified later.

All wrapper classes (except Character) define a constructor that accepts a String argument representing the primitive value that needs to be wrapped.

You can assign a primitive value directly to a reference variable of its wrapper class type—thanks to autoboxing. The reverse is unboxing, when an object of a primitive wrapper class is converted to its corresponding primitive value. I’ll discuss autoboxing and autounboxing in detail in the next section.

3) Retrieving primitive values from the wrapper classes:

All wrapper classes define methods of the format primitiveValue(), where primitive refers to the exact primitive data type name. Table shows a list of the classes and their methods to retrieve corresponding primitive values.

Example :

package com.gs.ilp.corejava.wrapperclasses;

public class WrapperExample1 {
	public static void main(String[] args) {

		//-----creation----
		
		//1) using primitives
		Boolean bool1 = true;
		Character char1 = 'a';
		Byte byte1 = 10;
		Double double1 = 10.98;

		//2) using constructor accepting literal
		Boolean bool2 = new Boolean(true);
		Character char2 = new Character('a');
		Byte byte2 = new Byte((byte) 10);
		Double double2 = new Double(10.98);

		//3) using constructor accepting String literal
		// Character char3 = new Character("a");
		Boolean bool3 = new Boolean("true");
		Byte byte3 = new Byte("10");
		Double double3 = new Double("10.98");

		//4) using static methods
		Boolean bool4 = Boolean.valueOf(true);
		Boolean bool5 = Boolean.valueOf(true);
		Boolean bool6 = Boolean.valueOf("TrUE");
		Double double4 = Double.valueOf(10);
		
		//--- getting primitives from wrapper
		
		boolean b1 = bool4.booleanValue();
		char c2 = char2.charValue();
		double d3= double4.doubleValue();
		byte b4 =  byte3.byteValue();
	}
}

4) Parsing a string value to a primitive type:

To get a primitive data type value corresponding to a string value, you can use the static utility method parseDataType(), where DataType refers to the type of the return value. Each wrapper class (except Character) defines a method, to parse a String to the corresponding primitive value, listed as follows:

package com.gs.ilp.corejava.wrapperclasses;

public class WrapperExample2 {
	public static void main(String[] args) {
		Long.parseLong("12.34");
		Byte.parseByte("1234");
		Boolean.parseBoolean("true");
		Boolean.parseBoolean("TrUe");
	}
}

Example 1:

package com.gs.ilp.corejava.wrapperclasses;

public class WrapperExample2 {
	public static void main(String[] args) {
		Long.parseLong(null);
		Byte.parseByte("1234");
		Boolean.parseBoolean("true");
		Boolean.parseBoolean("TrUe");
	}
}

CTE

5) Difference between using method valueOf() and constructors of wrapper classes