blocks|key|942156|text|a是对一些Integer(3)的“引用”，你的速记a%2B=b实际上意味着这样做：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|942157|a+=+new+Integer(3+%2B+3)|code-block|syntax|javascript|942158|所以，整数不是可变的，但是指向它们的变量是*。|942159|*可以有不可变的变量，这些变量由关键字final表示，这意味着引用可能不会改变。|942160|final+Integer+a+=+3;
final+Integer+b+=+3;
a+%2B=+b;+//+compile+error,+the+variable+`a`+is+immutable,+too.|942161|entityMap^0|0|1|P|4|0|0|0|J|5|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|Q|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|R|$]]

<code>a</code> is a "reference" to some Integer(3), your shorthand <code>a+=b</code> really means do this:

<pre><code>a = new Integer(3 + 3)
</code></pre>

So no, Integers are not mutable, but the variables that point to them are*.

*It's possible to have immutable variables, these are denoted by the keyword <code>final</code>, which means that the reference may not change.

<pre><code>final Integer a = 3;
final Integer b = 3;
a += b; // compile error, the variable `a` is immutable, too.
</code></pre>

blocks|key|942214|text|不可变并不意味着您不能更改变量的值。它只是意味着任何新的赋值都会创建一个新的对象(给它分配一个新的内存位置)，然后赋值给它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|942215|要自己理解这一点，请在循环中执行Integer赋值(在循环外声明integer+)，并查看内存中的活动对象。|942216|不可变对象不需要复制构造函数的原因是简单的常识。由于每个赋值都会创建一个新对象，因此该语言在技术上已经创建了一个副本，因此您不必再创建另一个副本。|942217|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Immutable does not mean that you cannot change value for a variable. It just means that any new assignment creates a new object ( assigns it a new memory location) and then the value gets assigned to it. 

To understand this for yourself, perform Integer assignment in a loop ( with integer declared outside the loop ) and look at the live objects in memory.

The reason why copy constructor is not needed for immutable objects is simple common sense. Since each assignment creates a new object, the language technically creates a copy already, so you do not have to create another copy.

blocks|key|726164|text|不可变并不意味着a永远不能等于另一个值。例如，String也是不可变的，但我仍然可以这样做：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|726165|String+str+=+"hello";
//+str+equals+"hello"
str+=+str+%2B+"world";
//+now+str+equals+"helloworld"|code-block|syntax|javascript|726166|str没有改变，相反，str现在是一个全新实例化的对象，就像您的Integer一样。因此，a的值并没有发生变化，而是被一个全新的对象所取代，即new+Integer(6)。|726167|entityMap^0|8|1|N|6|0|0|0|3|B|3|W|7|19|1|1Z|E|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|N|$]]

Immutable does not mean that <code>a</code> can never equal another value. For example, <code>String</code> is immutable too, but I can still do this:

<pre><code>String str = "hello";
// str equals "hello"
str = str + "world";
// now str equals "helloworld"
</code></pre>

<code>str</code> was not changed, rather <code>str</code> is now a completely newly instantiated object, just as your <code>Integer</code> is. So the value of <code>a</code> did not mutate, but it was replaced with a completely new object, i.e. <code>new Integer(6)</code>.

blocks|key|942326|text|是的，Integer是不可变的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|942327|A是指向对象的引用。当您运行%2B=+3时，这会重新分配A以引用一个新的整数对象，并使用不同的值。|942328|您从未修改过原始对象，而是将引用指向另一个对象。|942329|阅读objects和references+here之间的区别。|offset|length|942330|entityMap|0|LINK|mutability|MUTABLE|url|http://javaprepare.blogspot.com/2007/08/whats-differences-between-object-and.html^0|0|0|0|L|4|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@$H|V|I|W|1|X]]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

Yes Integer is immutable.

A is a reference which points to an object. When you run a += 3, that reassigns A to reference a new Integer object, with a different value.

You never modified the original object, rather you pointed the reference to a different object.

Read about the difference between objects and references <a href="http://javaprepare.blogspot.com/2007/08/whats-differences-between-object-and.html" rel="noreferrer">here</a>.

blocks|key|942372|text|您可以使用System.identityHashCode()确定对象是否已更改(更好的方法是使用普通的==，但是不太明显的是引用而不是值发生了更改)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|942373|Integer+a+=+3;
System.out.println("before+a+%2B=3;+a="%2Ba%2B"+id="%2BInteger.toHexString(System.identityHashCode(a)));
a+%2B=+3;
System.out.println("after+a+%2B=3;+a="%2Ba%2B"+id="%2BInteger.toHexString(System.identityHashCode(a)));|code-block|syntax|javascript|942374|打印|942375|before+a+%2B=3;+a=3+id=70f9f9d8
after+a+%2B=3;+a=6+id=2b820dda|942376|你可以看到a引用的对象的底层"id“已经改变了。|942377|entityMap^0|5|P|1F|2|0|0|0|0|5|1|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|R|$]]

You can determine that the object has changed using <code>System.identityHashCode()</code> (A better way is to use plain <code>==</code> however its not as obvious that the reference rather than the value has changed)

<pre><code>Integer a = 3;
System.out.println("before a +=3; a="+a+" id="+Integer.toHexString(System.identityHashCode(a)));
a += 3;
System.out.println("after a +=3; a="+a+" id="+Integer.toHexString(System.identityHashCode(a)));
</code></pre>

prints

<pre><code>before a +=3; a=3 id=70f9f9d8
after a +=3; a=6 id=2b820dda
</code></pre>

You can see the underlying "id" of the object <code>a</code> refers to has changed.

blocks|key|942464|text|对于最初提出的问题，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|942465|Integer+a=3;
Integer+b=3;
a%2B=b;
System.out.println(a);|code-block|syntax|javascript|942466|Integer是不可变的，所以上面发生的是'a‘已经变成了值6的新引用。初始值3在内存中没有引用(它没有被改变)，所以它可以被垃圾回收。|942467|如果字符串发生这种情况，它将在池中(在PermGen空间中)保留比整数更长的时间，因为它预计会有引用。|942468|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

To the initial question asked, 

<pre><code>Integer a=3;
Integer b=3;
a+=b;
System.out.println(a);
</code></pre>

Integer is immutable, so what has happened above is 'a' has changed to a new reference of value 6. The initial value 3 is left with no reference in the memory (it has not been changed), so it can be garbage collected. 

If this happens to a String, it will keep in the pool (in PermGen space) for longer period than the Integers as it expects to have references.

blocks|key|726388|text|这就是我对不可变的理解|type|unstyled|depth|inlineStyleRanges|entityRanges|data|726389|int+a=3;++++
int+b=a;
b=b%2B5;
System.out.println(a);+//this+returns+3
System.out.println(b);+//this+returns+8|code-block|syntax|javascript|726390|如果int可以改变，"a“将打印8，但它不会，因为它是不可变的，这就是为什么它是3。你的例子只是一个新的赋值。|726391|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

This is how I understand immutable

<pre><code>int a=3; 
int b=a;
b=b+5;
System.out.println(a); //this returns 3
System.out.println(b); //this returns 8
</code></pre>

If int could mutate, "a" would print 8 but it does not because it is immutable, thats why it is 3. Your example is just a new assignment.

blocks|key|726444|text|public+static+void+main(String[]+args)+{
++++//+TODO+Auto-generated+method+stub

++++String+s1="Hi";
++++String+s2=s1;

++++s1="Bye";

++++System.out.println(s2);+//Hi++(if+String+was+mutable+output+would+be:+Bye)
++++System.out.println(s1);+//Bye

++++Integer+i=1000;
++++Integer+i2=i;

++++i=5000;

++++System.out.println(i2);+//+1000
++++System.out.println(i);+//+5000

++++int+j=1000;
++++int+j2=j;

++++j=5000;

++++System.out.println(j2);+//+1000
++++System.out.println(j);+//++5000


++++char+c='a';
++++char+b=c;

++++c='d';

++++System.out.println(c);+//+d
++++System.out.println(b);+//+a
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|726445|输出为：|unstyled|726446|嗨，再见1000+5000+1000+5000+d+a|726447|因此char是可变的，String+Integer和int是不可变的。|726448|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>public static void main(String[] args) {
 // TODO Auto-generated method stub

 String s1="Hi";
 String s2=s1;

 s1="Bye";

 System.out.println(s2); //Hi (if String was mutable output would be: Bye)
 System.out.println(s1); //Bye

 Integer i=1000;
 Integer i2=i;

 i=5000;

 System.out.println(i2); // 1000
 System.out.println(i); // 5000

 int j=1000;
 int j2=j;

 j=5000;

 System.out.println(j2); // 1000
 System.out.println(j); // 5000


 char c='a';
 char b=c;

 c='d';

 System.out.println(c); // d
 System.out.println(b); // a
}
</code></pre>

Output is :

Hi
Bye
1000
5000
1000
5000
d
a

So char is mutable , String Integer and int are immutable.

blocks|key|942614|text|复制并运行这段代码，我希望这能解答你所有的疑惑|type|unstyled|depth|inlineStyleRanges|entityRanges|data|942615|private+static+void+wrapperClassDemo()+{
++++//checking+wrapper+class+immutability+using+valueOf+method
++++//We+can+create+wrapper+class+by+using+either+"new"+keyword+or+using+a+static+method+"valueOf()"
++++//The+below+Example+clarifies+the+immutability+concept+of+wrapper+class+in+detail
++++//For+better+understanding+just+ciopy+the+below+code+to+the+editor+and+run
++++++++
++++Integer+num1+=Integer.valueOf(34);++//+i'm+passing+the+34+as+the+parameter+to+the+valueOf+method
++++System.out.println("value+assigned+to+num1+is+:+"%2Bnum1);
++++System.out.println("Printing+the+hashcode+assigned+to+store+the+\"+num1+\"value+in+memory:+"%2BSystem.identityHashCode(num1));
++++++++
++++Integer+num2+=Integer.valueOf(34);
++++System.out.println("value+assigned+to+num2+is+:+"%2Bnum2);
++++System.out.println("Printing+the+hashcode+assigned+to+store+the+\"+num2+\"value+in+memory:+"%2BSystem.identityHashCode(num2));
++++++++
++++/*Now+u+can+notice+both+the+hashcode+value+of+num1+and+num2+are+same.+that+is+because+once+you+created+the+num1+with+the+value+34+an+object+is+
+++++*+created+in+the+heap+memory.+And+now+You+are+passing+the+value++same+as+num1+to+the+num2+.Now+JVM+Checks+the+same+value+is+present+in+the+heap+Mmeomry
+++++*+If+present+the+reference+variable(in+this+example+it+is+num2)+will++be+pointed+to+the+same+address+where+the+object+num1+is+stored+so+u+get+the+same+hashcode+++++++++*/
+++++++++
++++++++
++++num2%2B%2B;+//+You+can+use+num2+=+35+as+both+are+same;+
++++System.out.println("\nvalue+assigned+to+num2+is+:+"%2Bnum2);
++++System.out.println("Printing+the+hashcode+of++\"+num1+\":+"%2BSystem.identityHashCode(num1)+%2B+"\nPrinting+the+hashcode+of++\"+num2+\":+"%2BSystem.identityHashCode(num2));
++++System.out.println("As+now+you+can+notice+the+hashcode+has+changed+for+num2+,That+is+because+now+a+new+object+is+created+for+num2+and+it+is+referencing+the+new+object");
++++++++
++++//Again+i'm+incrementing+num2
++++System.out.println("\nBefore+incremeting++the+hashcode+of++\"+num2+\"+is:+"%2BSystem.identityHashCode(num2));
++++num2%2B%2B;+//+You+can+use+num2+=+36+as+both+are+same;
++++System.out.println("After+incremeting++the+hashcode+of++\"+num2+\"+is:+"%2BSystem.identityHashCode(num2));
++++//now+the+hashcode+value+of+num2+is+changed+,again+new+object+is+created+for+the+updated+value+and+num2+is+referencing+new+object+,and+old+object+will+be+garbage+collected
++++++++
++++System.out.println("\n+Thus+the+CONCLUSION+is+Wrapper+objects+are+immutable+,They+only+create+new+object+and+refernce+the+new+object+,They+won't+modify+the+present+object+");
++++System.out.println("This+is+applicable+for+Strings+also");|code-block|syntax|javascript|942616|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Copy and run this code,I hope this will answer all your doubts
<pre class="lang-java prettyprint-override"><code>private static void wrapperClassDemo() {
 //checking wrapper class immutability using valueOf method
 //We can create wrapper class by using either &quot;new&quot; keyword or using a static method &quot;valueOf()&quot;
 //The below Example clarifies the immutability concept of wrapper class in detail
 //For better understanding just ciopy the below code to the editor and run
 
 Integer num1 =Integer.valueOf(34); // i'm passing the 34 as the parameter to the valueOf method
 System.out.println(&quot;value assigned to num1 is : &quot;+num1);
 System.out.println(&quot;Printing the hashcode assigned to store the \&quot; num1 \&quot;value in memory: &quot;+System.identityHashCode(num1));
 
 Integer num2 =Integer.valueOf(34);
 System.out.println(&quot;value assigned to num2 is : &quot;+num2);
 System.out.println(&quot;Printing the hashcode assigned to store the \&quot; num2 \&quot;value in memory: &quot;+System.identityHashCode(num2));
 
 /*Now u can notice both the hashcode value of num1 and num2 are same. that is because once you created the num1 with the value 34 an object is 
 * created in the heap memory. And now You are passing the value same as num1 to the num2 .Now JVM Checks the same value is present in the heap Mmeomry
 * If present the reference variable(in this example it is num2) will be pointed to the same address where the object num1 is stored so u get the same hashcode */
 
 
 num2++; // You can use num2 = 35 as both are same; 
 System.out.println(&quot;\nvalue assigned to num2 is : &quot;+num2);
 System.out.println(&quot;Printing the hashcode of \&quot; num1 \&quot;: &quot;+System.identityHashCode(num1) + &quot;\nPrinting the hashcode of \&quot; num2 \&quot;: &quot;+System.identityHashCode(num2));
 System.out.println(&quot;As now you can notice the hashcode has changed for num2 ,That is because now a new object is created for num2 and it is referencing the new object&quot;);
 
 //Again i'm incrementing num2
 System.out.println(&quot;\nBefore incremeting the hashcode of \&quot; num2 \&quot; is: &quot;+System.identityHashCode(num2));
 num2++; // You can use num2 = 36 as both are same;
 System.out.println(&quot;After incremeting the hashcode of \&quot; num2 \&quot; is: &quot;+System.identityHashCode(num2));
 //now the hashcode value of num2 is changed ,again new object is created for the updated value and num2 is referencing new object ,and old object will be garbage collected
 
 System.out.println(&quot;\n Thus the CONCLUSION is Wrapper objects are immutable ,They only create new object and refernce the new object ,They won't modify the present object &quot;);
 System.out.println(&quot;This is applicable for Strings also&quot;);
</code></pre>

blocks|key|726512|text|要记住的是，现在有了一个用于Integer值的缓存。它有时可以避免开发人员在从整型更改为整型时使用==而不是.equals()的错误。不过，并不总是这样。当您实例化一个新的Integer时，将创建一个新的实例。因此，整数不仅是不可变的，而且是半静态的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|726513|++++Integer+a+=+3;
++++Integer+b+=+3;
++++Integer+c+=+new+Integer(3);
++++b+=+b+%2B+1;
++++b+=+b+-+1;

++++System.out.println("a-id:+"+%2B+System.identityHashCode(a));
++++System.out.println("b-id:+"+%2B+System.identityHashCode(b));
++++System.out.println("c-id:+"+%2B+System.identityHashCode(c));
++++System.out.println("a+==+b:+"+%2B+(a+==+b));
++++System.out.println("a+==+c:+"+%2B+(a+==+c));
++++System.out.println("a+eq+c:+"+%2B+(a.equals(c)));++++|code-block|syntax|javascript|726514|给出打印输出：|726515|a-id:+666988784|726516|b-id:+666988784|726517|c-id:+1414644648|726518|A+==+b:真|726519|A+==+c:+false|726520|a:+true|726521|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Something to hold in mind is that there is now a cache for Integer values. It sometimes saves developers from the mistake of using == instead of .equals() when changing from int to Integer. Not always though. When you instantiate a new Integer, there will be a new instance created. So Integers are not only immutable, but also semi static.
<pre><code> Integer a = 3;
 Integer b = 3;
 Integer c = new Integer(3);
 b = b + 1;
 b = b - 1;

 System.out.println(&quot;a-id: &quot; + System.identityHashCode(a));
 System.out.println(&quot;b-id: &quot; + System.identityHashCode(b));
 System.out.println(&quot;c-id: &quot; + System.identityHashCode(c));
 System.out.println(&quot;a == b: &quot; + (a == b));
 System.out.println(&quot;a == c: &quot; + (a == c));
 System.out.println(&quot;a eq c: &quot; + (a.equals(c))); 
</code></pre>
Gives the printout: 
a-id: 666988784 
b-id: 666988784 
c-id: 1414644648 
a == b: true 
a == c: false 
a eq c: true

I know this is probably very stupid, but a lot of places claim that the Integer class in Java is immutable, yet the following code:

<pre><code>Integer a=3;
Integer b=3;
a+=b;
System.out.println(a);
</code></pre>

Executes without any trouble giving the (expected) result 6. So effectively the value of a has changed. Doesn't that mean Integer is mutable?
Secondary question and a little offtopic: "Immutable classes do not need copy constructors". Anyone care to explain why?

Is Integer Immutable

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我知道这可能很愚蠢，但是很多地方声称Java中的Integer类是不可变的，但下面的代码：Integer a=3;Integer b=3;a+=b;System.out.println(a);执行时没有任何问题，给出了(预期的)结果6。因此，实际上a的值已经改变了。这不是意味着Integer是可变的吗？第二个问题和一些...

问Integer不可变
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Integer不可变EN