Wrapper Class in Java Interview Questions and Answers

1. What is a Wrapper Class in Java?

   • Answer: Wrapper classes in Java are classes that provide a mechanism to convert primitive data types (like `int`, `float`, `boolean`, etc.) into objects. This allows you to use primitive types in situations where objects are required, such as storing them in collections (like `ArrayList` or `HashMap`) which only accept objects.

2. Name the wrapper classes for each primitive data type.

   • Answer: `Integer` (for `int`), `Long` (for `long`), `Float` (for `float`), `Double` (for `double`), `Character` (for `char`), `Boolean` (for `boolean`), `Byte` (for `byte`), `Short` (for `short`).

3. How do you convert a primitive type to its wrapper class object (autoboxing)?

   • Answer: Java automatically performs this conversion, called autoboxing. For example: `Integer i = 10;` automatically converts the primitive `int` value 10 into an `Integer` object.

4. How do you convert a wrapper class object to its primitive type (unboxing)?

   • Answer: Java also automatically performs this conversion, called unboxing. For example: `int x = i;` automatically converts the `Integer` object `i` into its primitive `int` value.

5. What are the benefits of using Wrapper classes?

   • Answer: Wrapper classes allow you to use primitive types in collections, use null values (primitives cannot be null), and provide methods for working with the primitive values (like `parseInt()`, `doubleValue()`, etc.).

6. Explain the concept of immutability in wrapper classes.

   • Answer: Wrapper class objects are immutable. Once created, their values cannot be changed. Any operation that seems to modify the object actually creates a new object with the modified value.

7. What is the difference between `==` and `.equals()` when comparing wrapper objects?

   • Answer: `==` compares object references (memory addresses). `.equals()` compares the actual values of the objects. For wrapper objects, `==` will only return `true` if the objects are the same instance; `.equals()` will return `true` if the values are the same.

8. Explain the use of `valueOf()` method in wrapper classes.

   • Answer: `valueOf()` is a static method that converts a primitive type or a String representation into a wrapper object. For example, `Integer.valueOf("10")` converts the String "10" into an `Integer` object.

9. What is the purpose of `parseInt()`, `parseDouble()`, etc., methods?

   • Answer: These static methods in wrapper classes convert String representations of numbers into their corresponding primitive types. For example, `Integer.parseInt("10")` converts the String "10" into the `int` value 10.

10. How do you handle potential `NullPointerException` when unboxing?

    • Answer: Always check for `null` before unboxing to avoid `NullPointerException`. For example: `int x = (i != null) ? i.intValue() : 0;`

11. Can you explain the caching mechanism used by Integer class for small values?

    • Answer:The `Integer` class caches instances for values between -128 and 127. When you create an `Integer` object with a value within this range, the same cached instance is returned. This improves performance by reusing objects instead of creating new ones.

12. What is the significance of the `MAX_VALUE` and `MIN_VALUE` constants in wrapper classes?

    • Answer: These constants represent the maximum and minimum values that can be stored in the corresponding primitive data type. They are useful for validation and range checking.

Thank you for reading our blog post on 'Wrapper Class in Java Interview Questions and Answers'.We hope you found it informative and useful.Stay tuned for more insightful content!