CODEWITHSUNDEEP
javawrapper
PetrosB
PetrosB

Reputation: 4154

Are Java wrapper classes really immutable?

Java Wrapper classes are supposed to be immutable. This means that once an object is being created, e.g., 

Integer i = new Integer(5);

its value cannot be changed. However, doing 

i = 6;

is perfectly valid.

So, what does immutability in this context mean? Does this have to do with auto-boxing/unboxing? If so, is there any way to prevent the compiler from doing it?

Thank you

Upvotes: 20

Views: 16141

Answers (6)

Java wanna bee
Java wanna bee

Reputation: 3119

Integer i = new Integer(5);
i++;                         // i  will become 6

where i++ is the same with i = new Integer( i.intValue() + 1);

Upvotes: 0

Patchikori Rajeswari
Patchikori Rajeswari

Reputation: 69

All wrapper classes in java are immutable. We can't change the value of a wrapper class object once created, i.e., can't change the value wrapped inside the object. Because wrapper classes are used as object form of primitive data types and if they are mutable, data inconsistencies will occur in runtime. However, you can change the wrapper class reference variable to hold another object.

Upvotes: -1

josefx
josefx

Reputation: 15656

The compiler autoboxes primitive values, this means that 

Integer value = 6;

will be compiled as

Integer value = Integer.valueOf(6);

Integer.valueOf will return an Integer instance with the given value. In your case i will now reference the Integer(6) instead of the Integer(5), the Integer(5) object itself will not change.

To see this you can do following

Integer i = new Integer(5);//assign new integer to i
Integer b = i;//b refences same integer as i
i = 6;//modify i
System.out.println(i +"!="+b);

This will print 6!=5, if the integer instance had been modified it would print 6!=6 instead.

To clarify this is only meant to show how an assignment to Integer only modifies the reference and does not alter the Integer instance itself. As user @KNU points out it does not prove or show the immutability of Integer, as far as I can tell the immutability is only indirectly given by the lack of modifying methods in its API and the requirement that instances returned by Integer.valueOf have to be cached for a certain range.

Upvotes: 15

drekka
drekka

Reputation: 21883

The reason i = 6 works is that auto-boxing is intercepting and turning it into i = new Integer(6). Thus as @Peter said, you are now pointing at a new object.

Upvotes: 6

bmargulies
bmargulies

Reputation: 100051

i is a reference. Your code change the reference i to point to a different, equally immutable, Integer.

final Integer i = Integer.valueOf(5);

might be more useful.

Upvotes: 26

Petar Minchev
Petar Minchev

Reputation: 47373

Immutable means that the object state cannot be changed. In your case you haven't changed the object new Integer(5), but you have changed the reference i to point to another object. Hope it is clear:)

Upvotes: 19

Related Questions