不变性很好。参见有效的Java。如果每次传递String时都必须复制它，那么这将是大量容易出错的代码。您还会混淆哪些修改会影响哪些引用。同样地，Integer必须是不可变的才能像int一样，string必须是不可变的才能像原语一样。在c++中，按值传递字符串是这样做的，源代码中没有明确提到。

线程安全和性能。如果一个字符串不能被修改，那么在多个线程之间传递引用是安全且快速的。如果字符串是可变的，则总是必须将字符串的所有字节复制到新实例，或者提供同步。一个典型的应用程序在每次需要修改字符串时将读取字符串100次。参见维基百科关于不变性的内容。

在大多数情况下，“字符串”(被用作/视为/认为/假定)是一个有意义的原子单位，就像一个数字一样。

因此，问为什么字符串的单个字符是不可变的，就像问为什么整数的单个比特是不可变的一样。

你应该知道原因。想想看。

我不想这么说，但不幸的是，我们正在讨论这个问题，因为我们的语言很糟糕，我们试图使用一个单一的词，字符串，来描述一个复杂的，上下文定位的概念或对象类。

我们对“字符串”执行计算和比较，类似于对数字的操作。如果字符串(或整数)是可变的，我们必须编写特殊的代码来将它们的值锁定为不可变的局部形式，以便可靠地执行任何类型的计算。因此，最好将字符串视为数字标识符，但它可能是数百位，而不是16位、32位或64位。

When someone says "string", we all think of different things. Those who think of it simply as a set of characters, with no particular purpose in mind, will of course be appalled that someone just decided that they should not be able to manipulate those characters. But the "string" class isn't just an array of characters. It's a STRING, not a char[]. There are some basic assumptions about the concept we refer to as a "string", and it generally can be described as meaningful, atomic unit of coded data like a number. When people talk about "manipulating strings", perhaps they're really talking about manipulating characters to build strings, and a StringBuilder is great for that. Just think a bit about what the word "string" truly means.

考虑一下如果字符串是可变的会是什么样子。如果可变用户名字符串在此函数使用时被另一个线程有意或无意地修改，则以下API函数可能被欺骗返回不同用户的信息:

string GetPersonalInfo( string username, string password )
{
    string stored_password = DBQuery.GetPasswordFor( username );
    if (password == stored_password)
    {
        //another thread modifies the mutable 'username' string
        return DBQuery.GetPersonalInfoFor( username );
    }
}

安全不仅仅是“访问控制”，它还涉及“安全性”和“保证正确性”。如果一个方法不容易编写，也不能可靠地依靠它来执行简单的计算或比较，那么调用它是不安全的，但是对编程语言本身提出质疑是安全的。

我知道这是个意外，但是… 它们真的是不可变的吗? 考虑以下几点。

public static unsafe void MutableReplaceIndex(string s, char c, int i)
{
    fixed (char* ptr = s)
    {
        *((char*)(ptr + i)) = c;
    }
}

...

string s = "abc";
MutableReplaceIndex(s, '1', 0);
MutableReplaceIndex(s, '2', 1);
MutableReplaceIndex(s, '3', 2);
Console.WriteLine(s); // Prints 1 2 3

你甚至可以让它成为一个扩展方法。

public static class Extensions
{
    public static unsafe void MutableReplaceIndex(this string s, char c, int i)
    {
        fixed (char* ptr = s)
        {
            *((char*)(ptr + i)) = c;
        }
    }
}

是什么使下面的工作

s.MutableReplaceIndex('1', 0);
s.MutableReplaceIndex('2', 1);
s.MutableReplaceIndex('3', 2);

Conclusion: They're in an immutable state which is known by the compiler. Of couse the above only applies to .NET strings as Java doesn't have pointers. However a string can be entirely mutable using pointers in C#. It's not how pointers are intended to be used, has practical usage or is safely used; it's however possible, thus bending the whole "mutable" rule. You can normally not modify an index directly of a string and this is the only way. There is a way that this could be prevented by disallowing pointer instances of strings or making a copy when a string is pointed to, but neither is done, which makes strings in C# not entirely immutable.

不可变性与安全性并没有那么紧密的联系。为此，至少在。net中，你得到了SecureString类。

稍后编辑:在Java中，你会发现GuardedString，一个类似的实现。

根据Effective Java，第4章，第73页，第二版:

"There are many good reasons for this: Immutable classes are easier to design, implement, and use than mutable classes. They are less prone to error and are more secure. [...] "Immutable objects are simple. An immutable object can be in exactly one state, the state in which it was created. If you make sure that all constructors establish class invariants, then it is guaranteed that these invariants will remain true for all time, with no effort on your part. [...] Immutable objects are inherently thread-safe; they require no synchronization. They cannot be corrupted by multiple threads accessing them concurrently. This is far and away the easiest approach to achieving thread safety. In fact, no thread can ever observe any effect of another thread on an immutable object. Therefore, immutable objects can be shared freely [...]

同一章的其他要点:

不仅可以共享不可变对象，还可以共享它们的内部结构。 […] 不可变对象为其他对象提供了很好的构建块，无论是可变的还是不可变的。 […] 不可变类的唯一缺点是，它们需要为每个不同的值提供一个单独的对象。