为什么不变类Integer可以重置其值？

Question

I was reading earlier that wrapper classes are all immutable. Immutable means that the value cannot be changed. Below I tried this simple example that can just be pasted in to any main method. first I create a Integer that wraps the value five. Immutable means that they cannot be changed so why can I set I to 89. I think that it is because it changes where (I) points to but I am not certain why this is the case.

In my next little example i create an Integer of x which will throw an error if I try and change it. The x seems to be immutable in this specific case but not in the case of the (i) variable.

It seems that I can change the value of (i) whenever I want to so in reality Integer without the final keyword is not immutable???? If i can be set to 89 then to me this seems that the variable can be changed.

I have read other post on this and I still am not certain why i can be changed to another variable. Also in writing code what is the best way to declare primitive types. Why not use the wrapper classes all of the time to create variables.

int y = 5; 
Integer i = new Integer(y);
i = 89;
final Integer x = Integer.valueOf(5);

System.out.println("Integer:(i) " + i.intValue());
System.out.println("Integer:(i) " + i.byteValue());

System.out.println("Integer:(x) " + x.intValue());;
System.out.println("Integer:(x) " + x.byteValue());;

i = i - 5;

Using all wrapper classes to declare variables: (Would this be better than declaring these variable with the primitive variable types)

Integer a = new integer(MyNewValue);
Integer b = new integer(MyNewValue);
Integer c = new integer(MyNewValue);
Integer d = new integer(MyNewValue);
Float   fa = new integer(MyNewValue);

Answer 1

You are conflating two things: changing the value of an "object" itself and changing the object a reference points to. Saying i = 89 just points the variable i to a new object; it doesn't change the Integer object which originally was pointed to by i .

Pre-pending variable declarations with final just ensures that reassigned is prohibited, it is in no way a declaration of the mutability/immutability of the object it points to. Maybe off-topic, but I personally think the article Java is Pass-by-Value, Dammit! is a good read.

Answer 2

When you call i = 89; , your not changing the value of the Integer object stored in memory. Instead, you're assigning a brand new int with value 89 to i . So the immutable rule isn't being broken.

Remember that i is simply a reference that points to the Integer , not the actual Integer itself.

Answer 3

Yes, it does look like the integer is changing, but all that is happening on line 3 is its being converted to i = new Integer(89) by the compiler. If you wanted to see, you could do

Integer i1 = i;
i = 83;
println(i); \\ prints out the original value 5
println(i1); \\ prints out a new value, 83

When you declare something as final, you cannot change the definition of the variable, though you can still mutate anything inside it. JavaRanch has a very nice analogy to help

You should not use wrapper objects when you can avoid it because they are a small amount less efficient to than primitives and take up a few extra bytes.