Wrapper Class in Java | Java Wrapper Classes

In my years of programming with Java, the concept of a wrapper class in Java has been a cornerstone of my development work. These classes, designed to convert Java’s primitive data types into reference types, have been instrumental in enabling my projects to leverage the full power of object-oriented programming. From enhancing the functionality of collections to allowing null values and providing utility methods, wrapper classes have enriched my coding experience significantly.  

This article will take a deep dive into the world of Java Wrapper Classes, where I’ll share insights gained from hands-on experience. We’ll explore what wrapper classes are, their process flow, and how they’re used in Java programming. Additionally, we’ll also discuss the basics of primitive data types and the features of Java wrapper classes, as well as their advantages and disadvantages. Our goal is to provide fellow professionals aspiring to excel in Java with a comprehensive understanding of wrapper classes informed by real-world applications and scenarios. 

What is a Wrapper Class in Java?

Java is an object-oriented language that converts a primitive data type into a class object; hence, wrapper class objects enable us to convert the original passed value. These wrapper classes support the multithreading and synchronisation process. With the help of this, we can work with collections like Vector, LinkedList, ArrayList.

Java programming language offers java.lang package that includes the Object and Class. Along with the above overview on what is wrapper class in java, you must know what they represent. Java wrapper classes represent or wrap the primitive data types’ values as an object. When an object is defined in a wrapper class, it includes a field that can store the primitive data types’ values.

Note that the object of one data type includes a field of the specific data type only. So, an object’s double type contains the double type of the field only. It represents that value to store the corresponding reference in a reference type’s variable.

When a wrapper class object is created, the space is allocated in the memory. This is where the primitive data type is saved. Moreover, the wrapper class supports some functionalities for transforming the object into primitive data and, eventually, primitive data into the object. These conversion processes happen automatically. After we understand what is wrapper class in java, let’s go through the process flow of the wrapper class.

Check out our free courses to get an edge over the competition.

Process Flow of the Wrapper Class 

In a wrapper class, we create the object with fields or properties, where we can use and store the primitive data types. 

Java implements in-built classes corresponding to specific primitive types that can be applied to modify these value types in object types. We can consider and identify these inbuilt classes as wrapper classes or primitive wrapper classes.

Check out upGrad’s Advanced Certification in DevOps

Use of Wrapper Class in Java Programming

• We can use the wrapper class and create a function with parameters using primitive data types.
• We can change the primitive data type into a distinct wrapper class.
• Wrapper class allows various methods while using collections like sorting and searching.
• The wrapper class implements the technique to convert the primitive into object and object into primitive.
• There is a concept of autoboxing and unboxing in the wrapper class, which transform the primitives into objects and objects into primitives automatically.
• In Java, we have a synchronisation mechanism that works with objects in multithreading.

Check out upGrad’s Advanced Certification in Blockchain

Need for using Wrapper Classes in Java:

To understand how wrapper classes are helpful in Java, you should be clear about what are wrapper classes in java. The wrapper classes in java can be used when it is required to use the primitive types as objects. Moreover, wrapper classes also contain methods that unwrap the object and return the data type.

• The classes only handle objects in java.util package. In this case, the wrapper class proves to be useful.
• Data Structures like ArrayList only store the objects, not the primitive types in the Collection framework.
• The wrapper classes in java are used for the methods that support objects like a conversion from other types.
• Wrapper classes are useful for synchronization in multithreading. The synchronization process allows only one thread to use a shared resource at a time. For that, wrapper class objects are required.

What are Primitive Data Types?

After being familiar with what are wrapper classes in java and their usefulness, it’s important to learn about the primitive data types. Before going into a deeper understanding of the wrapper class object, we need to understand the concept of primitive data types:

A primitive data type defines the size and type of variable values. In Java, we have eight primitive data types, which are as follows:

Image source

f

Java is a statically-typed programming language, so any variable can’t be used without declaration. So, data types are used for variable declaration. Fundamentally, the data type is the type of variable that defines the value it may include and the operations that can be performed on it.

Primitive data types come with a limitation, i.e., they can contain data of the same type, and the size is fixed based on the data type. For instance, 1 byte can only store whole numbers ranging from -128 to 127. Moreover, the primitive data types always hold a value

Features of Java Wrapper Classes

1. Wrapper classes transmute numeric strings into numeric values.
2. We can store primitive data into an object.
3. We can use the valueOf() method in all the wrapper classes without string.
4. We can use the typeValue() for all the available wrapper classes. It performs as the primitive type and returns the value of the object.

Below are the Features of the Wrapper Class:

a. Modification of the value in function: In java programming, we have the ‘call by value’ function, with the help of which we can pass the primitive value parameter. In many cases, the argument needs to be modified so that we can pass the objects and accordingly modify the values.

b. Serialisation: In serialisation, we convert the object within streams to implement the serialisation. We can regenerate it in the object with the help of the classes of the wrapper. Objects are inevitable because the Serializable interface should be implemented by the class whose object is persevered.

c. Synchronisation: Java synchronisation operates into objects in multi-threading.

d. java.util package: The java.util package implements the utility classes to match with objects.

e. Collection framework: Java collection framework operates including objects only. Here, we have many collection framework classes—for example—HashSet, TreeSet, ArrayDeque, ArrayList, Vector, and LinkedList. All these collection framework classes only store objects, i.e., reference types, and not the primitive types. Hence, objects are wrapper classes’ instances, and therefore, they are helpful for this.

Also Read: Java Architecture & Components

Methods Supported by the Wrapper Classes

If you aim to thoroughly learn what is wrapper class, you must learn the supported methods described below:

 Some of the commonly used methods implemented by all subclasses of the Number class are described here:

typeValue() -Converts the value of the particular Number object to the stated primitive data type returned

compareTo() – Compares the Number object with the argument

equals()   – Checks whether the Number object equals the argument

valueOf() – Returns an Integer object containing the specified primitive data type’s value

toString() – Returns a String object containing the specified Integer type argument’s value

parseInt() – Returns an Integer type value of a stated String representation

decode() – Decodes a String into an integer

min() – Compares the two arguments and returns the smaller value

max() – Compares the two arguments and returns the bigger value

round() – Returns the closest round off of int or long value according to the method return type

upGrad’s Exclusive Software Development Webinar for you –

SAAS Business – What is So Different?

Use of Autoboxing and Unboxing in Wrapper Class with Examples

Autoboxing: It is the automated transformation of primitive types to the object of their corresponding wrapper classes—for example, conversion of long to Long and int to Integer, double to Double.

The Java compiler implements autoboxing when a primitive value is:

• Passed as a parameter to a method that requires an object of the equivalent wrapper class
• Assigned to the equivalent wrapper classes’ variable

Advantages of Wrapper Classes 

In my journey as a Java developer, the utility of wrapper classes in Java has been invaluable. Here are the key advantages of the wrapper class in Java I’ve encountered: 

• Object Conversion: They allow primitive data types to be treated as objects, which is crucial for collections like ArrayList. This was pivotal in a banking application, enabling seamless handling of account balances. 
• Utility Methods: Wrapper classes offer methods for data manipulation, such as parsing strings to primitives, which is essential in a data processing tool I developed for type conversions. 
• Collections Compatibility: Since Java collections operate on objects, wrapper classes enable storing primitives in collections like ArrayList, enhancing operations like sorting and searching, which was beneficial in a complex data structuring project. 
• Null Support: They can hold null, providing an elegant solution for managing optional data, a feature I leveraged in a web service for handling optional request parameters without extra checks. 

In essence, the advantages of the wrapper class in Java have significantly contributed to developing flexible, robust Java applications, bridging the gap between primitives and object-oriented programming with practical benefits in real-world projects. 

Disadvantages of Wrapper Classes

In Java programming, wrapper classes play a pivotal role in transitioning between primitive types and the object-oriented framework that Java promotes. While these classes are invaluable for certain applications, it’s crucial to acknowledge the inherent disadvantages of wrapper classes that come with their use. 

• Performance Overhead: Utilizing a wrapper class in Java introduces performance overhead due to the additional layer of abstraction. For instance, in a high-frequency trading application where millisecond-level efficiency is crucial, the slight delay caused by boxing and unboxing can lead to significant performance degradation. 
• Increased Memory Usage: Wrapper classes consume more memory compared to their primitive counterparts. In an embedded system project I worked on, optimizing memory usage was paramount. The use of wrapper classes initially posed a challenge due to their higher memory footprint, necessitating a careful balance between object-oriented benefits and memory efficiency. 
• Null Pointer Exceptions: Another disadvantage of the wrapper class in Java is the risk of encountering Null Pointer Exceptions. When a wrapper object is null, attempting to unbox it can cause a Null Pointer Exception. This issue became apparent in a system I developed for processing user inputs, where unexpected null values led to runtime exceptions that had to be meticulously handled. 

Unboxing in Java

Unboxing is the reverse of Autoboxing. It is the method of converting a Wrapper class object within its corresponding Primitive Data type. For example, we can convert an Integer object into a primitive data type, as int.

The Java compiler implements unboxing when a wrapper class’ object is:

• Assigned to the corresponding primitive type’s variable
• Passed as a parameter to a method that requires the corresponding primitive type’s value

 Need for Autoboxing and Unboxing in Java:

• The addition of autoboxing and unboxing greatly simplifies the coding of many algorithms. They eliminate the need for manually boxing and unboxing the values.
• It helps avoid errors.
• It is quite significant to generics that execute only on objects.

Benefits of Wrapper Classes

• Wrapper class provides various methods which we can use with collections like sorting, searching.
• We can use the objects of the wrapper class and store them as a null value.
• A wrapper type allows a primitive to operate in more advanced ways. An integer can use it in different ways, like a class described as Hours, for example, which presents the number meaning wherever it is used.
• The primitive types just operate value; the wrapper class provides it with a name.
• Wrapper objects are natural objects, and their references can be null. This enables the usage of a ‘not set’ state, which is difficult with primitives.
• Objects like Integer and Character are pointers. The variable’s value in bytes shows an address in the memory. They are the references to the memory address. Hence, it is possible to set that number to an address that directs to nowhere.
• A primitive data type like char or int contains a number that is interpreted as a number only (ASCII code or integer). Since the memory can only store numbers, there is no alternative to making it ‘not a number’.
• A wrapper class allows a primitive data type to work in various innovative ways. An integer can use this data type in various ways. For example, a class ‘Hours’ will always represent the number wherever it is used.
• The primitive types only run with the value, whereas the wrapper class provides a name. For example, int as Integer means only int specifies the value’s type and range. However, by creating the object with the wrapper class ‘Integer’, it will be provided a reference name(object).
• All the numeric wrapper classes are subclasses of the abstract class “Number” including Integer, Byte, Short, Double, Long, and Float.

Checkout: Java Projects & Topics

Learn Software Courses online from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs, or Masters Programs to fast-track your career.

Conclusion

In wrapping up our exploration of wrapper class in Java, we’ve journeyed through the fundamentals, from what these classes are to their role in the Java programming ecosystem. We’ve dissected the process flow of a wrapper class, examined their use in programming, and delved into the nuances of primitive data types.

Alongside this, we’ve highlighted the indispensable features of Java wrapper classes and illustrated the practicality of autoboxing and unboxing with real-world examples. Understanding the wrapper class in Java is essential for leveraging Java’s object-oriented capabilities fully, making your code more flexible, robust, and maintainable. As you continue to navigate through the complexities of Java programming, let the insights from this article guide your path to becoming a more proficient and informed Java developer.

If you’re interested to learn more about Java, full-stack development, check out upGrad & IIIT-B’s Executive PG Program in Full-stack Software Development which is designed for working professionals and offers 500+ hours of rigorous training, 9+ projects, and assignments, IIIT-B Alumni status, practical hands-on capstone projects & job assistance with top firms.