{"id":12776,"date":"2023-02-13T07:12:33","date_gmt":"2023-02-13T07:12:33","guid":{"rendered":"https:\/\/www.prepbytes.com\/blog\/?p=12776"},"modified":"2023-10-16T07:12:31","modified_gmt":"2023-10-16T07:12:31","slug":"wrapper-class-in-java","status":"publish","type":"post","link":"https:\/\/prepbytes.com\/blog\/wrapper-class-in-java\/","title":{"rendered":"Wrapper Class in Java"},"content":{"rendered":"

\"\"<\/p>\n

In Java, primitive data types like int, char, and float are simple and efficient for basic data storage, but they lack the flexibility to work with objects and perform certain operations. To bridge this gap between primitive types and objects, Java provides a set of wrapper classes. Wrapper classes are a group of classes that encapsulate primitive data types, allowing them to be treated as objects.
\nIn this article, we’ll explore the concept of wrapper classes in Java. We’ll discuss why and when you should use wrapper classes, how to create instances of wrapper classes, and the various methods they provide for converting between primitive types and objects. Understanding wrapper classes is crucial for working with collections, generics, and other Java features that require objects instead of primitives.<\/p>\n

What is a Wrapper Class in Java?<\/h2>\n

A Wrapper class in Java is a class that wraps around a primitive data type and converts it into an object. Wrapper classes provide a way to treat primitive data types, such as int or double, as objects. This allows you to use the primitive data types in places where only objects are accepted, such as in collections. The eight primitive data types (boolean, char, byte, short, int, long, float, and double) in Java are not objects, but the wrapper classes (Boolean, Character, Byte, Short, Integer, Long, Float, and Double) are.<\/p>\n

Each Wrapper class in java has a constructor that takes a single argument of the corresponding primitive data type. For example, you can use the Integer class to convert an int value into an Integer object:<\/p>\n

int i = 42;\nInteger iWrapped = new Integer(i);<\/code><\/pre>\n
Wrapper classes also provide utility methods for converting primitive values to and from binary and hexadecimal representations:<\/p>\n
int i = 42;\nString binary = Integer.toBinaryString(i);\nString hex = Integer.toHexString(i);<\/code><\/pre>\n
Another important aspect of Wrapper classes is the ability to use them in place of primitive data types in collections, such as arrays and lists. Since the primitive data types are not objects, they cannot be directly stored in collections. The Wrapper classes provide a way to store primitive values as objects:<\/p>\n
List list = new ArrayList();\nlist.add(42);<\/code><\/pre>\n
The Wrapper classes also provide methods for comparing and manipulating the values they contain. For example, the Integer class provides methods for comparing two Integer objects, such as compareTo(), equals(), and compare():<\/p>\n
Integer i1 = 42;\nInteger i2 = 43;\nint result = i1.compareTo(i2);<\/code><\/pre>\n
And the Character class provides methods for testing the type of characters and converting them to uppercase or lowercase:<\/p>\n
Character c = 'a';\nboolean isLowerCase = Character.isLowerCase(c);\nchar upperCase = Character.toUpperCase(c);<\/code><\/pre>\n
Wrapper classes also provide support for autoboxing and unboxing, which allows you to use primitive data types and Wrapper objects interchangeably. Autoboxing is the process of converting a primitive value into an object of the corresponding Wrapper class in java automatically, while unboxing is the process of converting a Wrapper object back into a primitive value. This makes it possible to use Wrapper objects and primitive values interchangeably in your code:<\/p>\n
int i = 42;\nInteger iWrapped = i; \/\/ Autoboxing\nint j = iWrapped; \/\/ Unboxing<\/code><\/pre>\n
Summarising Wrapper class in java provides a way to treat primitive data types as objects in Java. They provide a set of utility methods for converting, comparing, and manipulating primitive values, and are particularly useful for working<\/p>\n
Need of Wrapper Class in Java<\/h3>\n
Wrapper classes in Java are used to wrap primitive data types (such as int, char, and boolean) in an object. This is necessary because in Java, everything is an object, and objects are required in certain situations, such as when a method requires an object as a parameter or when you need to store multiple values in a single structure like an ArrayList or a HashMap.<\/p>\n
Each primitive data type has a corresponding wrapper class: Integer for int, Character for char, Boolean for boolean, etc. Wrapper classes provide useful methods for converting primitive values to and from strings, comparing values, and performing other operations.<\/p>\n
For example, the Integer class has a static method called parseInt that can be used to convert a string representation of an integer into an int value, and the toString method can be used to convert an int value into a string. This can be particularly useful when reading data from a file or user input.<\/p>\n
Another benefit of using wrapper classes is that they provide an easy way to represent null values. When a primitive value is set to its default value (such as 0 for int or false for boolean), it is unclear whether the value was explicitly set to that default or if it has not been initialized. By using a wrapper class, you can set a reference to null, which makes it clear that the value has not been initialized.<\/p>\n
Wrapper classes also allow you to use primitive data types in collections, such as ArrayList, where only objects can be stored. By wrapping the primitive value in an object, you can store it in the collection.<\/p>\n
In conclusion, the wrapper classes in Java serve a crucial purpose in providing a way to represent primitive data types as objects. They offer a convenient way to perform various operations on primitive values and also provide a way to store null values and use primitive data types in collections.<\/p>\n
In Java, the eight classes that make up the java.lang package are referred to as wrapper classes. Following is a list of the eight wrapper classes:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n
Primitive Type<\/th>\nWrapper Class<\/th>\n<\/tr>\n<\/thead>\n
char<\/td>\nCharacter<\/td>\n<\/tr>\n
short<\/td>\nShort<\/td>\n<\/tr>\n
long<\/td>\nLong<\/td>\n<\/tr>\n
double<\/td>\nDouble<\/td>\n<\/tr>\n
boolean<\/td>\nBoolean<\/td>\n<\/tr>\n
byte<\/td>\nByte<\/td>\n<\/tr>\n
int<\/td>\nInteger<\/td>\n<\/tr>\n
float<\/td>\nFloat<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Uses of Wrapper Class in Java<\/h2>\n
The main uses of the wrapper class in Java are<\/p>\n
    \n
  • Representing primitive data types as objects:<\/strong> Wrapper classes provide a way to use primitive data types as objects, which is necessary in certain situations where only objects are accepted, such as in collections like ArrayList and HashMap.<\/li>\n
  • Storing null values:<\/strong> Primitive data types in Java cannot store null values, but wrapper classes can be set to null, which can be useful in representing missing or unknown values.<\/li>\n
  • Method parameters:<\/strong> Wrapper classes can be used as method parameters, allowing methods to accept objects instead of primitive data types.<\/li>\n
  • Autoboxing and unboxing:<\/strong> Wrapper classes provide automatic conversions between primitive data types and their corresponding wrapper objects through a feature called autoboxing and unboxing.<\/li>\n
  • Converting between primitive data types and strings:<\/strong> Wrapper classes provide methods for converting primitive values to and from strings, which can be useful for reading data from a file or user input.<\/li>\n
  • Comparing values:<\/strong> Wrapper classes provide methods for comparing values, such as equals() and compareTo(), which can be useful for sorting and searching.<\/li>\n
  • Performing mathematical operations:<\/strong> Wrapper classes provide methods for performing mathematical operations, such as addition, subtraction, and multiplication, on primitive values.<\/li>\n<\/ul>\n
    Autoboxing in Java<\/h2>\n
    Autoboxing in Java refers to the automatic conversion of primitive data types to their corresponding wrapper classes. This feature was introduced in Java 5 and makes it easier to use primitive values in situations where only objects are accepted, such as in collections and method parameters.
    \nPrior to Java 5, converting a primitive value to its corresponding wrapper class in java required manual conversion, using the constructor of the wrapper class.<\/p>\n
    Example of Autoboxing<\/h3>\n
    Here we will look at the example of autoboxing in the wrapper class in java<\/p>\n
    Code:<\/strong><\/p>\n\t\t\t\t\t\t