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

其中一个含义与值如何存储在计算机中有关，例如，对于一个。net字符串，它意味着内存中的字符串不能被更改，当你认为你正在更改它时，你实际上是在内存中创建了一个新的字符串，并将现有的变量(这只是一个指向其他地方的实际字符集合的指针)指向新的字符串。

“不可变”意味着你不能改变值。如果你有一个String类的实例，你调用的任何方法，只要看起来是在修改这个值，实际上都会创建另一个String。

String foo = "Hello";
foo.substring(3);
<-- foo here still has the same value "Hello"

要保存更改，您应该这样做 Foo = Foo .sustring(3);

当您使用集合时，不可变与可变可能会很有趣。想想如果使用可变对象作为map的键，然后更改值会发生什么(提示:考虑equals和hashCode)。

不可改变的意思是不可改变的。字符串对象一旦创建，其数据或状态就不能更改

考虑下面的例子:

class Testimmutablestring{  
  public static void main(String args[]){  
    String s="Future";  
    s.concat(" World");//concat() method appends the string at the end  
    System.out.println(s);//will print Future because strings are immutable objects  
  }  
 }  

让我们考虑一下波纹图，

在这个图中，你可以看到一个新对象被创建为“Future World”。但不改变“未来”。因为字符串是不可变的。s，仍指“未来”。如果你需要给“未来世界”打电话，

String s="Future";  
s=s.concat(" World");  
System.out.println(s);//print Future World

为什么在java中字符串对象是不可变的?

因为Java使用了字符串字面量的概念。假设有5个引用变量，都指向一个对象“Future”。如果一个引用变量改变了对象的值，它将影响到所有的引用变量。这就是为什么字符串对象在java中是不可变的。

不可变意味着一旦对象被创建，它的所有成员都不会改变。字符串是不可变的，因为你不能改变它的内容。 例如:

String s1 = "  abc  ";
String s2 = s1.trim();

在上面的代码中，字符串s1没有改变，使用s1创建了另一个对象(s2)。

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仍然在内存中，但是 我们无法访问它…