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

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

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

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

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

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

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

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

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

java.time

这可能有点晚了，但为了理解什么是不可变对象，请考虑以下来自新的Java 8日期和时间API (Java . Time)的示例。你可能知道，Java 8中的所有日期对象都是不可变的，所以在下面的例子中

LocalDate date = LocalDate.of(2014, 3, 18); 
date.plusYears(2);
System.out.println(date);

输出:

2014-03-18

这将打印与初始日期相同的年份，因为plusYears(2)返回一个新对象，因此旧日期仍然不变，因为它是一个不可变对象。一旦创建，您就不能进一步修改它，日期变量仍然指向它。

因此，该代码示例应该捕获并使用由plusYears调用实例化并返回的新对象。

LocalDate date = LocalDate.of(2014, 3, 18); 
LocalDate dateAfterTwoYears = date.plusYears(2);

date.toString()…2014-03-18 dateAfterTwoYears.toString()…2016-03-18

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