Introduction

In Java, primitive data types (like int, float, char, etc.) are not objects. However, many Java features such as Collections, Generics, and various object-based APIs work only with objects.

To solve this, Java provides Wrapper Classes such as Integer, Double, Character, Boolean, etc., which act as object representations of primitive types.

Before Java 5, developers had to manually convert between primitives and wrapper objects — a process called Boxing and Unboxing.

From Java 5 onward, Java introduced Autoboxing and Auto-unboxing, where these conversions happen automatically.

1. Boxing (Manual Conversion)

Definition:

Boxing means manually converting a primitive data type into its corresponding wrapper class object. Before Java 5, this was done using the valueOf() method of wrapper classes.

Example 1:

int num = 10;
Integer obj = Integer.valueOf(num); // Boxing

Example 2:

double d = 7.25;
Double wrapper = Double.valueOf(d);
System.out.println("Wrapper object: " + wrapper);

2. Unboxing (Manual Conversion)

Definition:

Unboxing is the reverse of Boxing — it means manually converting a wrapper object back into a primitive value. Before Java 5, this was done using methods like intValue(), doubleValue(), etc.

Example 1:

Integer obj = Integer.valueOf(25);
int num = obj.intValue(); // Unboxing

Example 2:

Double obj = Double.valueOf(12.5);
double val = obj.doubleValue(); // Unboxing
System.out.println("Primitive value: " + val);

Note: Using constructors like new Integer() or new Double() is deprecated in modern Java versions. Prefer using valueOf() instead.

Why Was This Changed?

Before Java 5, developers had to manually convert primitives to wrappers (and vice versa) whenever they used Collections or Generics.

This made code long, repetitive, and harder to read.

This change allowed the compiler to perform conversions automatically, making Java code cleaner and more readable.

3. Autoboxing (Automatic Conversion)

Definition:

Autoboxing is the automatic conversion of a primitive value into its corresponding wrapper class object. When you assign a primitive to a wrapper type, Java automatically wraps it.

Example 1:

int number = 10;       // Primitive
Integer obj = number;  // Autoboxing: int → Integer

Example 2:

char ch = 'A';
Character c = ch; // Autoboxing: char → Character
System.out.println("Character object: " + c);

4. Auto-unboxing (Automatic Conversion)

Definition:

Auto-unboxing is the automatic conversion of a wrapper object back into its primitive type.

Example 1:

Integer obj = 25;  // Wrapper object
int num = obj;     // Auto-unboxing: Integer → int

Example 2:

Double obj = 5.5;
double value = obj; // Auto-unboxing
System.out.println("Primitive value: " + value);

Autoboxing and Auto-unboxing with Collections

Collections such as ArrayList, HashMap, and others can only store objects, not primitives. Autoboxing and Auto-unboxing make it easier to work with primitive data types in such collections.

import java.util.*;

public class ShikshaSanchar {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();

        // Autoboxing: primitive → wrapper
        numbers.add(5);
        numbers.add(10);
        numbers.add(15);

        // Auto-unboxing: wrapper → primitive
        for (int n : numbers) {  // enhanced for-loop automatically unboxes
            System.out.println(n);
        }
    }
}

Advantages of Autoboxing and Auto-unboxing

• Simplifies code — no manual conversions required.
• Increases readability and reduces redundancy.
• Enables the use of primitive data types in Collections and Generics.
• Improves compatibility with APIs and frameworks that work with objects.
• Makes Java more user-friendly and object-oriented.

Key Points

Summary: