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

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

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写了一篇关于这个的博客文章。基本上，你可以拥有接口是不可变的对象，但在幕后实际可变的私有状态(因此不能在线程之间安全地共享)。

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

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

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

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

考虑下面的例子:

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

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

不过，澄清一下，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是一个可变对象，因为它可以在不创建新实例的情况下进行更改。

不可变对象是指创建后不能修改的对象。一个典型的例子是字符串字面量。

越来越流行的D编程语言通过“不变”关键字具有“不变性”的概念。查看Dr.Dobb关于它的文章http://dobbscodetalk.com/index.php?option=com_myblog&show=Invariant-Strings.html&Itemid=29。它完美地解释了这个问题。