Java: Why are wrapper classes needed?

Because Java collections can only store Object References (so you need to box primitives to store them in collections).

Read this short article on Autoboxing for more info.

If you want the nitty gritty details, it pretty much boils down to the following:

Local Primitives are stored on the Stack. Collections store their values via a reference to an Object's memory location in the Heap. To get that reference for a local primitive, you have to box (take the value on the Stack and wrap it for storage on the Heap) the value.

Read all of the answers, but none of them really explains it simply in layman terms.

A wrapper class wraps(encloses) around a data type (can be any primitive data type such as int, char, byte, long) and makes it an object.

Here are a few reasons why wrapper classes are needed:

1. Allows null values.

2. Can be used in collection such as List, Map, etc.

3. Can be used in methods which accepts arguments of Object type.

4. Can be created like Objects using new ClassName() like other objects:

   Integer wrapperInt = new Integer("10");
   

5. Makes available all the functions that Object class has such as clone(), equals(), hashCode(), toString() etc.

Wrapper classes can be created in two ways:

1. Using constructor:

   Integer i = new Integer("1"); //new object is created
   

2. Using valueOf() static method:

    Integer i  = Integer.valueOf("100"); //100 is stored in variable
   

It is advised to use the second way of creating wrapper classes as it takes less memory as a new object is not created.

At the virtual machine level, it's because primitive types are represented very differently in memory compared to reference types like java.lang.Object and its derived types. Primitive int in Java for example is just 4 bytes in memory, whereas an Object takes up at minimum 8 bytes by itself, plus another 4 bytes for referencing it. Such design is a simple reflection of the fact that CPUs can treat primitive types much more efficiently.

So one answer to your question "why wrapper types are needed" is because of performance improvement that it enables.

But for programmers, such distinction adds some undesirable cognitive overhead (e.g., can't use int and float in collections.) In fact, it's quite possible to do a language design by hiding that distinction --- many scripting languages do this, and CLR does that. Starting 1.5, Java does that, too. This is achieved by letting the compiler silently insert necessary conversion between primitive representation and Object representation (which is commonly referred to as boxing/unboxing.)

So another answer to your question is, "no, we don't need it", because the compiler does that automatically for you, and to certain extent you can forget what's going on behind the scene.

To store the Primitive type values in Collection. We require Wrapper classes.