Java Wrapper Classes

Java Wrapper Classes provide a way to use primitive data types (like int, char, etc.) as objects. This feature is particularly useful when working with Java’s Collections Framework or in scenarios where objects are required instead of primitives.

In this tutorial by The Coding College, we’ll explore what wrapper classes are, how they work, and their practical applications.

What Are Wrapper Classes?

Each primitive data type in Java has a corresponding wrapper class in the java.lang package. These classes “wrap” the primitive type into an object.

Why Use Wrapper Classes?

1. Object-Oriented Collections: Collections like ArrayList and HashMap work with objects, not primitives.
2. Utility Methods: Wrapper classes provide methods for parsing and manipulating data.
3. AutoBoxing and UnBoxing: Java automatically converts between primitives and wrapper objects (introduced in Java 5).

Creating Wrapper Objects

You can create wrapper objects using their constructors or utility methods.

Example:

public class Main {
    public static void main(String[] args) {
        // Using constructors (Deprecated in newer versions)
        Integer num1 = new Integer(10);

        // Using valueOf() method
        Integer num2 = Integer.valueOf(20);

        // Using AutoBoxing (automatic conversion)
        Integer num3 = 30;

        System.out.println(num1 + ", " + num2 + ", " + num3);
    }
}

UnBoxing: Converting Objects to Primitives

UnBoxing is the process of converting wrapper objects back into primitive data types.

Example:

public class Main {
    public static void main(String[] args) {
        Integer num = 100; // AutoBoxing
        int primitiveNum = num; // UnBoxing

        System.out.println("Primitive Number: " + primitiveNum);
    }
}

Wrapper Classes and Utility Methods

Each wrapper class provides utility methods for common tasks. Below are some examples:

Parsing Strings to Primitives

public class Main {
    public static void main(String[] args) {
        String str = "123";
        int num = Integer.parseInt(str);

        System.out.println("Parsed Number: " + num);
    }
}

Converting Primitives to Strings

public class Main {
    public static void main(String[] args) {
        int num = 456;
        String str = Integer.toString(num);

        System.out.println("Converted String: " + str);
    }
}

Practical Example: Using Wrapper Classes in Collections

Primitive types cannot be stored in collections directly, but wrapper classes allow this.

Code:

import java.util.ArrayList;

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

        // Adding primitive data using AutoBoxing
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        // Iterating through the list
        for (Integer num : numbers) {
            System.out.println(num);
        }
    }
}

Output:

10
20
30

Comparing Wrapper Classes and Primitives

Best Practices

1. Minimize Overhead: Use primitives where objects are not required.
2. Avoid NullPointerException: Check for null values when working with wrapper classes.
3. Use AutoBoxing Wisely: Understand the performance implications of frequent boxing and unboxing.

Conclusion

Java Wrapper Classes bridge the gap between primitive data types and objects. They are essential for working with collections, utility methods, and type conversion. For more insightful tutorials, visit The Coding College and continue advancing your programming knowledge!