Scribd
Upload
0 views

Wrapper Classes in Java _ GeeksforGeeks

Wrapper classes in Java are used to encapsulate primitive data types into objects, enabling functionalities such as modification and storage in data structures that require objects. Autoboxing and unboxing are processes that automatically convert between primitive types and their corresponding wrapper classes. Custom wrapper classes can also be created to manage specific data structures, providing additional advantages like method invocation and null value support.

Uploaded by

Ayush Jha
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
0 views

Wrapper Classes in Java _ GeeksforGeeks

Wrapper classes in Java are used to encapsulate primitive data types into objects, enabling functionalities such as modification and storage in data structures that require objects. Autoboxing and unboxing are processes that automatically convert between primitive types and their corresponding wrapper classes. Custom wrapper classes can also be created to manage specific data structures, providing additional advantages like method invocation and null value support.

Uploaded by

Ayush Jha
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 7

Search...

54

Java Course Java Arrays Java Strings Java OOPs Java Collection Java 8 Tutorial Java Multith

Wrapper Classes in Java


Last Updated : 15 Apr, 2025

A Wrapper class in Java is one whose object wraps or contains


primitive data types. When we create an object in a wrapper class, it
contains a field, and in this field, we can store primitive data types. In
other words, we can wrap a primitive value into a wrapper class object.
Let’s check on the wrapper classes in Java with examples.

Example: Demonstration to convert the primitive to its corresponding


wrapper.

// Java program to demonstrate wrapping of primitive data types


// into their corresponding wrapper class
class Geeks
{
public static void main(String[] args)
{
// Primitive data type
int b;

// Integer wrapper class


Integer a;

// assigning value to primitive


b = 357;

// auto-boxing or auto wrapping


// converting primitive int to Integer object
a = b;

System.out.println("The primitive int b is: " + b);


System.out.println("The Integer object a is: " + a);
}
}

Output

The primitive int b is: 357


The Integer object a is: 357
Explanation: In the above example, we first create an primitive int b and
assign a value 357. Then we assign this primitive value to an Integer
object b and it automatically covert it to primitve to a Integer
object(Autoboxing).

Need of Wrapper Classes


There are certain needs for using the Wrapper class in Java as
mentioned below:

They 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 handle only objects and hence
wrapper classes help in this case.
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.

Below are given examples of wrapper classes in Java with their


corresponding Primitive data types in Java.

Primitive Data Types and their Corresponding


Wrapper Classes

Primitive Data Type Wrapper Class

char Character

byte Byte

short Short

int Integer
Primitive Data Type Wrapper Class

long Long

float Float

double Double

boolean Boolean

Autoboxing and Unboxing

1. Autoboxing

The automatic conversion of primitive types to the object of their


corresponding wrapper classes is known as autoboxing. For example –
conversion of int to Integer, long to Long, double to Double, etc.

Example: Java program to demonstrate the automatic conversion of


primitive to wrapper class (Autoboxing).

// Java program to demonstrate Autoboxing


import java.util.ArrayList;

class Geeks
{
public static void main(String[] args)
{
char ch = 'a';

// Autoboxing- primitive to Character object


// conversion
Character a = ch;

ArrayList<Integer> arrayList
= new ArrayList<Integer>();

// Autoboxing because ArrayList stores only objects


arrayList.add(25);

// printing the values from object


System.out.println(arrayList.get(0));
}
}

Output

25

2. Unboxing

It is just the reverse process of autoboxing. Automatically converting an


object of a wrapper class to its corresponding primitive type is known as
unboxing. For example, conversion of Integer to int, Long to long,
Double to double, etc.

Example: Java program demonstrates automatic conversion of wrapper


class to primtivie (Unboxing).

// Java program to demonstrate Unboxing


import java.util.ArrayList;

class Geeks
{
public static void main(String[] args)
{
Character ch = 'a';

// unboxing - Character object to primitive


// conversion
char a = ch;

ArrayList<Integer> arrayList
= new ArrayList<Integer>();
arrayList.add(24);

// unboxing because get method returns an Integer


// object
int num = arrayList.get(0);

// printing the values from primitive data types


System.out.println(num);
}
}

Output

24
Java Wrapper Classes Example

// Java program to demonstrate Wrapping


// and UnWrapping in Classes
import java.io.*;

class Geeks {
public static void main(String[] args)
{
// byte data type
byte a = 1;

// wrapping around Byte object (use valueOf or autoboxing)


Byte byteobj = Byte.valueOf(a);

// int data type


int b = 10;

// wrapping around Integer object (use valueOf or autoboxing)


Integer intobj = Integer.valueOf(b);

// float data type


float c = 18.6f;

// wrapping around Float object (use valueOf or autoboxing)


Float floatobj = Float.valueOf(c);

// double data type


double d = 250.5;

// Wrapping around Double object (use valueOf or autoboxing)


Double doubleobj = Double.valueOf(d);

// char data type


char e = 'a';

// wrapping around Character object (autoboxing)


Character charobj = e;

// printing the values from objects


System.out.println(
"Values of Wrapper objects (printing as objects)");
System.out.println("\nByte object byteobj: "
+ byteobj);
System.out.println("\nInteger object intobj: "
+ intobj);
System.out.println("\nFloat object floatobj: "
+ floatobj);
System.out.println("\nDouble object doubleobj: "
+ doubleobj);
System.out.println("\nCharacter object charobj: "
+ charobj);

// objects to data types (retrieving data types from


// objects) unwrapping objects to primitive data
// types
byte bv = byteobj;
int iv = intobj;
float fv = floatobj;
double dv = doubleobj;
char cv = charobj;

// printing the values from data types


System.out.println(
"\nUnwrapped values (printing as data types)");
System.out.println("\nbyte value, bv: " + bv);
System.out.println("\nint value, iv: " + iv);
System.out.println("\nfloat value, fv: " + fv);
System.out.println("\ndouble value, dv: " + dv);
System.out.println("\nchar value, cv: " + cv);
}
}

Output:

Custom Wrapper Classes in Java


Java Wrapper classes wrap the primitive data types. We can create a
class that wraps data inside it. So let us check how to create our own
custom wrapper class in Java. It can be implemented for creating certain
structures like queues, stacks, etc.

Example:

// Java Program to implement


// Custom wrapper class
import java.io.*;

// wrapper class
class Maximum {
private int maxi = 0;
private int size = 0;
public void insert(int x)
{
this.size++;
if (x <= this.maxi)
return;
this.maxi = x;
}

public int top() { return this.maxi; }

public int elementNumber() { return this.size; }


};

class Geeks {
public static void main(String[] args)
{
Maximum x = new Maximum();
x.insert(12);
x.insert(3);
x.insert(23);

System.out.println("Maximum element: " + x.top());


System.out.println("Number of elements inserted: "
+ x.elementNumber());
}
}

Output

Maximum element: 23
Number of elements inserted: 3

Advantages of Wrapper Classes

Collections allow only object data.


On object data we can call multiple methods compareTo(), equals(),
toString()
The cloning process only works on objects
Object data allows null values.
Serialization allows only object data.

Comment More info


Next Article

You might also like