Java不可变字符串混乱

Question

If String s are immutable in Java, then how can we write as:

String s = new String();
s = s + "abc";

Answer 1

Strings are immutable.
That means that an instance of String cannot change.

You're changing the s variable to refer to a different (but still immutable) String instance.

Answer 2

Your string variable is NOT the string. It's a REFERENCE to an instance of String.

See for yourself:

String str = "Test String";
System.out.println( System.identityHashCode(str) ); // INSTANCE ID of the string

str = str + "Another value";
System.out.println( System.identityHashCode(str) ); // Whoa, it's a different string!

The instances the str variable points to are individually immutable, BUT the variable can be pointed to any instance of String you want.

If you don't want it to be possible to reassign str to point to a different string instance, declare it final:

final String str = "Test String";
System.out.println( System.identityHashCode(str) ); // INSTANCE ID of the string

str = str + "Another value"; // BREAKS HORRIBLY

Answer 3

The first answer is absolutely correct. You should mark it as answered.

s = s+"abc" does not append to the s object. it creates a new string that contains the characters from the s object (of which there are none) and "abc".

if string were mutable. it would have methods like append() and other such mutating methods that are on StringBuilder and StringBuffer.

Effective Java by Josh Bloch has excellent discussion on immutable objects and their value.

Answer 4

Immutable Classes are those whose methods can change their fields, for example:

Foo f = new Foo("a");
f.setField("b"); // Now, you are changing the field of class Foo

but in immutable classes, eg String, you cannot change the object once you create it, but of course , you can reassign the reference to another object. For example:

String s = "Hello";
s.substring(0,1); // s is still "Hello"
s = s.substring(0,1); // s is now referring to another object whose value is "H"

Answer 5

   String s = new String();  

Creates a new, immutable, empty string, variable "s" references it.

   s = s+"abc";              

Creates a new, immutable, string; the concatenation of the empty string and "abc", variable "s" now references this new object.

Answer 6

Just to clarify, when you say s = s+"abc"; That means, create a new String instance (which is composed of s and "abc") then assign that new String instance to s. So the new reference in s is different from the old.

Remember, a variable is effectively a reference to an object at some specific memory location. The object at that location stays at that location, even if you change the variable to refer to a new object at a different location.

Answer 7

String s = new String();

An empty String object ( "" ) is created. And the variable s refers to that object.

s = s + "abc";

"abc" is a string literal (which is nothing but a String object, which is implicitly created and kept in a pool of strings) so that it can be reused (since strings are immutable and thus are constant). But when you do new String() is totally different because you are explicitly creating the object so does not end up in the pool. You can throw is in the pool by something called interning.

So, s + "abc" since at this point concatenation of and empty string ( "" ) and "abc" does not really create a new String object because the end result is "abc" which is already in the pool. So, finally the variable s will refer to the literal "abc" in the pool.

Answer 8

I believe you are all making this much more complicated than it needs to be, and that simply confuses people who are trying to learn!

The primary benefit of making an object immutable in Java is that it can be passed by reference (eg to another method or assigned using the assignment operator) without having to worry about downstream changes to the object causing issues in the current method or context. (This is very different than any conversation about the thread safety of an object.)

To illustrate, create an application that passes a String as a parameter to a separate method, and modify the String in that method. Print the String at the end of the called method and then after control returns to the calling method. The Strings will have different values, and that's because they point to different memory locations, a direct result of "changing" the immutable String (creating a new pointer and pointing it to a new value behind the scenes). Then create an application that does the same things except with StringBuffer, which is not immutable. (For example, you can append to the StringBuffer to modify it.) The printed StringBuffers will have the same values, and that is because it is (a) being passed by reference, as Java does with all objects passed to methods as parameters and (b) mutable.

I hope this helps folks who are reading this thread and trying to learn!