我真的很喜欢SCJP Sun认证程序员Java 5学习指南的解释。

为了提高Java的内存效率，JVM留出了一个特殊的内存区域，称为“字符串常量池”。当编译器遇到String字面值时，它会检查池，看看是否已经存在相同的String。如果找到匹配，则对新字面值的引用将指向现有的String，并且不会创建新的String字面值对象。

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

s1="Hi":创建一个包含"Hi"值的对象s1。

S2 =s1:引用s1对象创建对象S2。

s1="Bye":之前的s1对象的值不会改变，因为s1有String类型，而String类型是一个不可变的类型，相反，编译器创建了一个新的String对象与"Bye"值和s1引用它。在这里，当我们打印s2值时，结果将是“Hi”而不是“Bye”，因为s2引用了前一个具有“Hi”值的s1对象。

实际上，如果你使用上面建议的维基百科定义，String不是不可变的。

字符串的状态改变后构造。看一下hashcode()方法。String将hashcode值缓存在本地字段中，但直到第一次调用hashcode()才计算它。这种对hashcode的惰性求值将String置于一个有趣的位置，作为状态发生变化的不可变对象，但如果不使用反射，就无法观察到它发生了变化。

所以也许不可变的定义应该是一个不能被观察到已经改变的对象。

如果一个不可变对象在创建后状态发生了变化，但是没有人可以看到它(没有反射)，这个对象仍然是不可变的吗?

一旦实例化，就不能更改。考虑一个类，它的实例可能用作哈希表或类似的键。查看Java最佳实践。

不可变意味着一旦一个对象的构造函数完成执行，该实例就不能被改变。

这很有用，因为这意味着你可以传递对对象的引用，而不用担心其他人会改变它的内容。特别是在处理并发性时，对于永不更改的对象不存在锁定问题

e.g.

class Foo
{
     private final String myvar;

     public Foo(final String initialValue)
     {
         this.myvar = initialValue;
     }

     public String getValue()
     {
         return this.myvar;
     }
}

Foo不必担心getValue()的调用者可能会更改字符串中的文本。

如果你想象一个类似于Foo的类，但是成员是StringBuilder而不是String，你可以看到getValue()的调用者能够改变Foo实例的StringBuilder属性。

还要注意你可能会发现的不同类型的不变性:Eric Lippert写了一篇关于这个的博客文章。基本上，你可以拥有接口是不可变的对象，但在幕后实际可变的私有状态(因此不能在线程之间安全地共享)。

In large applications its common for string literals to occupy large bits of memory. So to efficiently handle the memory, the JVM allocates an area called "String constant pool".(Note that in memory even an unreferenced String carries around a char[], an int for its length, and another for its hashCode. For a number, by contrast, a maximum of eight immediate bytes is required) When complier comes across a String literal it checks the pool to see if there is an identical literal already present. And if one is found, the reference to the new literal is directed to the existing String, and no new 'String literal object' is created(the existing String simply gets an additional reference). Hence : String mutability saves memory... But when any of the variables change value, Actually - it's only their reference that's changed, not the value in memory(hence it will not affect the other variables referencing it) as seen below....

字符串s1 = "旧字符串";

//s1 variable, refers to string in memory
        reference                 |     MEMORY       |
        variables                 |                  |

           [s1]   --------------->|   "Old String"   |

字符串s2 = s1;

//s2 refers to same string as s1
                                  |                  |
           [s1]   --------------->|   "Old String"   |
           [s2]   ------------------------^

s1 = "New String";

//s1 deletes reference to old string and points to the newly created one
           [s1]   -----|--------->|   "New String"   |
                       |          |                  |
                       |~~~~~~~~~X|   "Old String"   |
           [s2]   ------------------------^

原来的字符串'in memory'没有改变，但是 引用变量已被更改，以便它引用新字符串。 如果我们没有s2, Old String仍然在内存中，但是 我们无法访问它…