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对象。

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

不可变对象是不能通过编程改变的对象。它们特别适用于多线程环境或其他多个进程能够更改(突变)对象中的值的环境。

不过，澄清一下，StringBuilder实际上是一个可变对象，而不是不可变对象。常规的java String是不可变的(意味着一旦创建了它，就不能在不改变对象的情况下更改底层字符串)。

例如，假设我有一个名为ColoredString的类，它有一个String值和一个String颜色:

public class ColoredString {

    private String color;
    private String string;

    public ColoredString(String color, String string) {
        this.color  = color;
        this.string = string;
    }

    public String getColor()  { return this.color;  }
    public String getString() { return this.string; }

    public void setColor(String newColor) {
        this.color = newColor;
    }

}

在这个例子中，ColoredString被认为是可变的，因为您可以在不创建新的ColoredString类的情况下更改(突变)它的一个关键属性。这可能很糟糕的原因是，例如，假设您有一个GUI应用程序，它有多个线程，并且您正在使用ColoredStrings将数据打印到窗口。如果你有一个ColoredString的实例，它被创建为

new ColoredString("Blue", "This is a blue string!");

然后你会期望字符串总是“Blue”。然而，如果另一个线程获得了这个实例并调用

blueString.setColor("Red");

当你想要一个“蓝色”的字符串时，你会突然，很可能出乎意料地得到一个“红色”的字符串。正因为如此，在传递对象实例时，几乎总是首选不可变对象。在确实需要可变对象的情况下，通常只需从特定的控制字段传递副本来保护对象。

概括一下，在Java中，Java .lang. string是一个不可变对象(一旦创建就不能更改)，而Java .lang. stringbuilder是一个可变对象，因为它可以在不创建新实例的情况下进行更改。

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

考虑下面的例子:

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中是不可变的。

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

不可变的对象在创建后不能改变其状态。

尽可能使用不可变对象有三个主要原因，所有这些都将有助于减少你在代码中引入的错误数量:

It is much easier to reason about how your program works when you know that an object's state cannot be changed by another method Immutable objects are automatically thread safe (assuming they are published safely) so will never be the cause of those hard-to-pin-down multithreading bugs Immutable objects will always have the same Hash code, so they can be used as the keys in a HashMap (or similar). If the hash code of an element in a hash table was to change, the table entry would then effectively be lost, since attempts to find it in the table would end up looking in the wrong place. This is the main reason that String objects are immutable - they are frequently used as HashMap keys.

当你知道一个对象的状态是不可变的时，你还可以在代码中做一些其他的优化——例如缓存计算的哈希——但这些都是优化，因此没有那么有趣。