不可变对象是其内部字段（或至少影响其外部行为的所有内部字段）无法更改的对象。
不可变字符串有很多优点：
性能：进行如下操作：
String substring = fullstring.substring(x,y);
substring() 方法的底层 C 可能是这样的：
// Assume string is stored like this:
struct String { char* characters; unsigned int length; };
// Passing pointers because Java is pass-by-reference
struct String* substring(struct String* in, unsigned int begin, unsigned int end)
{
struct String* out = malloc(sizeof(struct String));
out->characters = in->characters + begin;
out->length = end - begin;
return out;
}
请注意，不必复制任何字符！如果 String 对象是可变的（字符可能稍后会更改），那么您必须复制所有字符，否则会更改子字符串稍后会反映在另一个字符串中。
并发性：如果一个不可变对象的内部结构是有效的，它就永远是有效的。不同的线程不可能在该对象中创建无效状态。因此，不可变对象是线程安全的。
垃圾收集：垃圾收集器更容易对不可变对象做出合乎逻辑的决定。
但是，不变性也有缺点：
性能：等等，我以为你说性能是不变性的一个好处！嗯，有时是，但并非总是如此。取以下代码：
foo = foo.substring(0,4) + "a" + foo.substring(5); // foo is a String
bar.replace(4,5,"a"); // bar is a StringBuilder
这两行都将第四个字符替换为字母“a”。第二段代码不仅更具可读性，而且速度更快。看看你将如何为 foo 做底层代码。子字符串很简单，但现在因为在空格 5 处已经有一个字符并且其他东西可能正在引用 foo，所以你不能只更改它；您必须复制整个字符串（当然，其中一些功能被抽象为真正底层 C 中的函数，但这里的重点是显示在一个地方全部执行的代码）。
struct String* concatenate(struct String* first, struct String* second)
{
struct String* new = malloc(sizeof(struct String));
new->length = first->length + second->length;
new->characters = malloc(new->length);
int i;
for(i = 0; i < first->length; i++)
new->characters[i] = first->characters[i];
for(; i - first->length < second->length; i++)
new->characters[i] = second->characters[i - first->length];
return new;
}
// The code that executes
struct String* astring;
char a = 'a';
astring->characters = &a;
astring->length = 1;
foo = concatenate(concatenate(slice(foo,0,4),astring),slice(foo,5,foo->length));
请注意，concatenate 被调用 两次，这意味着必须循环整个字符串！将此与 bar 操作的 C 代码进行比较：
bar->characters[4] = 'a';
可变字符串操作显然要快得多。
结论：在大多数情况下，您需要一个不可变的字符串。但是，如果您需要对字符串进行大量附加和插入操作，则需要可变性以提高速度。如果你想要并发安全和垃圾收集的好处，关键是让你的可变对象保持在方法的本地：
// This will have awful performance if you don't use mutable strings
String join(String[] strings, String separator)
{
StringBuilder mutable;
boolean first = true;
for(int i = 0; i < strings.length; i++)
{
if(!first) first = false;
else mutable.append(separator);
mutable.append(strings[i]);
}
return mutable.toString();
}
由于mutable 对象是本地引用，因此您不必担心并发安全性（只有一个线程会接触它）。而且由于它没有在其他任何地方引用，它只在堆栈上分配，所以一旦函数调用完成它就会被释放（你不必担心垃圾收集）。您还可以获得可变性和不变性的所有性能优势。