What is the main difference between primitive type and wrapper class?

Question

What is the difference between these two lines?

    int pInt = 500;

and

    Integer wInt = new Integer(pInt);

Or

    Integer wInt = new Integer(500);

Dextrorse

Answer 1

None.

That's the exact same thing. In the first case you just have a supplementary variable.

Note that with autoboxing you rarely need to have both an int and an Integer variables. So for most cases this would be enough :

int pInt = 500;

The main case where the Integer would be useful is to distinguish the case where the variable is not known (ie null) :

Integer i = null; // possible
int i = null; // not possible because only Object variables can be null

But don't keep two variables, one is enough.

Eskil

There should be some different like using other methods in wrapper class such as int p2 = wInt.intValue(); – Dextrorse

That's hardly useful when you could simply use p2=pInt;. Note that the Integer object isn't even mutable. – Estivate

you said is a good way to distinguish an object is null. In another answer @Sumit Singh said I can't define an int null, but I can say Integer is null. What do you think? – Dextrorse

We're saying the same thing : if you want to have a non defined integer, you must use a Integer variable as you can't set a int variable as null. – Estivate

Answer 2

In Java, an instance of a primitve class holds the actual value of the instance, but instance of a wrapper class holds a reference to the object. i.e. The address of the place where the object would be found.

When you write a program with this line:

Integer integer = 500;

The compiler changes it to this:

Integer integer = new Integer(500);

This process is called autoboxing. That is automatically putting a primitive-instance in a "box" of Integer. Hence, output of the following program:

public class PrimitiveToObject {
    public static void main(String[] args) {
        printClassName(1);
        printClassName(1L);
        printClassName((char)1);
    }
    public static void printClassName(Object object){
        System.out.println(object.getClass());
    }
}

is this:

class java.lang.Integer
class java.lang.Long
class java.lang.Character

Also this:

int i = integer;

changes into this:

int i = integer.intValue();

This is called unboxing.

As you can see above, the dot operator(.) is used on the variable named integer but not on i. That is: a wrapper's object can be dereferenced, but not a primitive instance.

Boxing and unboxing may slow down the program a little bit. Hence, to a newbie, wrappers may look like added burden, but they are not so. Wrappers are used at places where the object needs to be a reference type. eg: Map<Integer,String>map=new HashMap<Integer,String>(); is a valid statement, but Map<int,String>map=new HashMap<int,String>(); is not a valid statement.

Another typical case where wrapper is very useful:
In MySQL, NULL is a valid entry for a column of INT type. But in Java, int cannot have a null value, Integer can. This is because in SQL NULL symbolises Not Available. So if you are using JDBC to insert integer values in a MySQL table, a null in your java program will help in inserting NULL in the MySQL table.

A wrapper class can also be useful in a case similar or anologous to this:

Boolean decision; // Using wrapper for boolean.
if("YES".equalsIgnoreCase(consent))
    decision = Boolean.TRUE; // In favour
else if("NO".equalsIgnoreCase(consent))
    decision = Boolean.FALSE; // Not in favour
else if("CAN'T SAY".equalsIgnoreCase(consent))
    decision = null; // Undecided

Broadleaved

Answer 3

For starters

int pInt = 500; , here pInt is not an object whereas in

Integer wInt = new Integer(500); wInt is an reference

This is also a reason why java is not pure Object Oriented Language. Because everything is not object with java.

Bainter

Answer 4

Wrapper class will have a box in that box it will cover the primitive data types there are 8 primitive data types namely byte,int ,long ,double, float, short ,Boolean ,char these all covered in wrapper class .

to use primitive data types we use like int a;

but to use wrapper class we need to use like Integer a = new Integer(i);

Mainly

Answer 5

The types of data are the same, but there are situations that manipulation of objects is more convenient than primitive types, like data structures, where you need more control of your data types.
For example, objects can be null and primitive types can't.
You also can't call methods in a primitive type (.compareTo(), .equals(), ...), but in wrapper classes you can.

The information below describe the types in primitive and wrapper class:

Primitive Types | Wrapper Class (Superclass = Object)

• boolean - Boolean
• char - Character
  

Primitive Types | Wrapper Class (Superclass = Number)

• byte - Byte
• short - Short
• int - Integer
• long - Long
• float - Float
• double - Double
  

To understand how the wapper classes works, consider the example below:

public final class IntWrapper { 
    private final int intVal;
    IntWrapper(int intVal) {
            this.intVal = intVal;
    }
    public int getInt() {
           return intVal;
   }
}

Now we can make an object out of our new IntWrapper class and 'box' the primitive int value 41:

int i = 41;
IntWrapper iw = new IntWrapper( i ); // box the primitive int type value into the object
i = iw.getInt(); // unbox the value from the wrapper object

My example IntWrapper class is immutable, immutable means that once its state has been initialized its state cannot be changed. When the final keyword is applied to a class, the final class cannot be extended. In other words, a final class can never be the superclass of a subclass. A final class can be the subclass of superclass, not problem there. When a class is marked final, all of its methods are implicitly final as well.

It is important to note that when final is applied to a reference variable it does not prevent the members of the object instance from changing values.

This example is to better understanding how the wrapper classes works inside.

Next, to create Integer, Double and other wrapper classes, you can write:

Integer i = new Integer(4);
Double d = new Double(9.62);
Boolean b = new Boolean("true");
Character c = new Character('M');

To get the encapsulated number into wrapper objects, you can write:

long l = i.longValue();
double e = i.doubleValue();
float f = d.floatValue();
short s = d.shortValue();

Each wrapper class include special methods to convert between primitive type to wrapper objects, that represent not number values:

boolean bo = b.booleanValue();
char ch = c.charValue();

Up to Java 5 version, the creation of objects from wrapper classes had to be in the syntaxes like above, but to simplify these operations, mainly related to insertion of values in the data structures offered in Java collections (that only accept objects), now exists the autoboxing or boxing and autounboxing or unboxing options.

The autoboxing or boxing allows you to insert a primitive value to reference of equivalent wrapper types or Object type:

// Same result of Double d = new Double(-2.75);
Double objD = -2.75;
// Same result of Object objI = new Integer(13);
Object objI = 13;

The autounboxing or unboxing allows you to insert a wrapper object into a variable of primitive type, converting automatically between equivalent types:

// Same result of double vd = objD.doubleValue();
double vd = objD;
// Same result of int vi = objI.intValue();
int vi = objI;

Villareal

Answer 6

The most important practical difference I've seen is Integer is way more slower to initialize and do calculations with, than int. I would avoid Integer unless necessary.

int x = 20_000_000;// 20 millions
for (int i = 0; i < x; i++) {
    ix += 23;
    }

it takes 138 ms(average over 50 trials) to complete the loop when ix is an Integer but only takes 10 ms when ix is an int

Caution