Wrapper Classes and Autoboxing

Table of Contents

1. Introduction to Wrapper Classes
2. What are Wrapper Classes?
   • Primitive Data Types vs. Wrapper Classes
3. The Purpose of Wrapper Classes
   • Converting Between Primitive Types and Objects
4. Commonly Used Wrapper Classes
   • Integer, Double, Character, and Boolean
5. Autoboxing in Java
   • Automatic Conversion Between Primitives and Wrapper Objects
6. Unboxing in Java
   • Converting Wrapper Objects to Primitive Types
7. Wrapper Class Methods
   • Useful Methods in Wrapper Classes
8. When to Use Wrapper Classes
   • Practical Use Cases and Examples
9. Summary

1. Introduction to Wrapper Classes

In Java, wrapper classes are used to represent the primitive data types as objects. Since Java is an object-oriented programming language, many libraries and frameworks rely on objects to pass data around. Wrapper classes allow primitives to behave like objects, enabling their use in collections such as lists and maps, which require objects rather than primitives.

Java provides a wrapper class for each of the eight primitive data types. These classes encapsulate the primitive values as objects, providing methods that allow you to perform operations such as parsing, comparing, and converting.

2. What Are Wrapper Classes?

A wrapper class is simply a class that wraps a primitive data type into an object. For example:

• int is wrapped by the Integer class
• double is wrapped by the Double class
• char is wrapped by the Character class
• boolean is wrapped by the Boolean class

In Java, the eight wrapper classes are:

• Byte for byte
• Short for short
• Integer for int
• Long for long
• Float for float
• Double for double
• Character for char
• Boolean for boolean

These classes are part of the java.lang package and are frequently used for their functionality in object manipulation and conversions.

Example:

int num = 5;
Integer wrappedNum = new Integer(num);  // Using the wrapper class Integer

In the above example, the primitive int is wrapped into an Integer object.

3. The Purpose of Wrapper Classes

Wrapper classes serve multiple purposes in Java programming, such as:

1. Storing Primitives in Collections: Collections like ArrayList, HashMap, etc., only accept objects. Thus, primitive types must be wrapped in their corresponding wrapper classes to be stored in these collections.
2. Utility Methods: Wrapper classes provide various utility methods like parseInt, parseDouble, valueOf, etc., to convert strings to primitive values or to perform other operations.
3. Autoboxing and Unboxing: They simplify the process of converting between primitive types and their object counterparts automatically (autoboxing) or manually (unboxing).
4. Support for Null Values: Unlike primitive types, which cannot hold null, wrapper objects can be assigned null, which is useful when working with databases or collections that may contain missing values.

4. Commonly Used Wrapper Classes

Below are the most commonly used wrapper classes in Java and their corresponding primitive types:

• Integer: Wraps the primitive int.
• Double: Wraps the primitive double.
• Character: Wraps the primitive char.
• Boolean: Wraps the primitive boolean.

Example:

int i = 10;
Integer intWrapper = Integer.valueOf(i);  // Converting primitive to wrapper class

double d = 25.5;
Double doubleWrapper = Double.valueOf(d);  // Converting primitive to wrapper class

Here, Integer.valueOf() and Double.valueOf() are used to convert primitive types to their corresponding wrapper objects.

5. Autoboxing in Java

Autoboxing is the automatic conversion of a primitive type to its corresponding wrapper class by the Java compiler. It eliminates the need for explicit boxing, making the code cleaner and more readable.

Example of Autoboxing:

public class Main {
    public static void main(String[] args) {
        int num = 10;
        Integer wrappedNum = num;  // Autoboxing: int to Integer
        System.out.println(wrappedNum);  // Output: 10
    }
}

In the above code, the primitive int (num) is automatically converted into an Integer object without needing to explicitly call new Integer(num) or Integer.valueOf(num).

Autoboxing is particularly useful when adding primitive values into collections such as ArrayList.

Example with Collection:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);  // Autoboxing: primitive int automatically converted to Integer
        list.add(20);
        
        System.out.println(list);  // Output: [10, 20]
    }
}

6. Unboxing in Java

Unboxing is the reverse of autoboxing. It refers to the automatic conversion of a wrapper object back to its corresponding primitive type. Java automatically unboxes wrapper classes to primitive types when needed.

Example of Unboxing:

public class Main {
    public static void main(String[] args) {
        Integer wrappedNum = new Integer(10);
        int num = wrappedNum;  // Unboxing: Integer to int
        System.out.println(num);  // Output: 10
    }
}

In this example, the Integer object wrappedNum is automatically converted to the primitive int (num) without needing explicit code for conversion.

Unboxing simplifies the process of working with wrapper objects and primitive types together.

7. Wrapper Class Methods

Each wrapper class comes with a set of useful methods that allow for conversions, comparisons, and other operations. Some of the commonly used methods in wrapper classes are:

• parseX(String): Converts a string to a corresponding primitive type (parseInt, parseDouble, parseBoolean, etc.). Example: String str = "123"; int num = Integer.parseInt(str); // Converts string to int System.out.println(num); // Output: 123
• valueOf(): Converts a primitive to a wrapper object. Example: int num = 10; Integer wrappedNum = Integer.valueOf(num);
• toString(): Returns the string representation of the primitive value. Example: Integer wrappedNum = new Integer(100); String str = wrappedNum.toString(); // Converts Integer to String System.out.println(str); // Output: "100"
• compareTo(): Compares two wrapper objects (useful for sorting or ordering). Example: Integer a = 10; Integer b = 20; System.out.println(a.compareTo(b)); // Output: -1 (because 10 < 20)

8. When to Use Wrapper Classes

While wrapper classes are incredibly useful, they should be used judiciously. Here are some typical use cases:

1. Working with Collections: Collections like ArrayList, HashMap, and other generic collections require objects, and wrapper classes provide an easy way to store primitive types in these collections. Example: ArrayList<Double> priceList = new ArrayList<>(); priceList.add(12.5); // Autoboxing from primitive double to Double
2. Nullability: If you need to represent the absence of a value (e.g., in databases or configuration data), wrapper objects like Integer, Boolean, or Double can be assigned null (unlike primitives).
3. Working with APIs: Many Java APIs, including JDBC and JavaFX, require wrapper classes for working with primitive values.

9. Summary

In this module, we covered wrapper classes and autoboxing in Java:

• Wrapper Classes provide a way to treat primitive types as objects and are used for tasks like storing primitives in collections and performing object-specific operations.
• Autoboxing automatically converts primitives to their corresponding wrapper objects, making code cleaner and less error-prone.
• Unboxing reverses this process by automatically converting wrapper objects back to primitive values.
• Wrapper classes come with useful methods for conversion, comparison, and string manipulation.

These features are critical for working with collections, APIs, and performing type conversions between primitive types and their object equivalents.