不可变性意味着实例化对象的值不能改变，你永远不能把“Hello”变成“Help!”

变量str是一个对象的引用，当你给str赋一个新值时，你没有改变它引用的对象的值，你引用的是一个不同的对象。

对于那些想知道如何在Java中打破字符串不变性的人…

Code

import java.lang.reflect.Field;

public class StringImmutability {
    public static void main(String[] args) {
        String str1 = "I am immutable";
        String str2 = str1;

        try {
            Class str1Class = str1.getClass();
            Field str1Field = str1Class.getDeclaredField("value");

            str1Field.setAccessible(true);
            char[] valueChars = (char[]) str1Field.get(str1);

            valueChars[5] = ' ';
            valueChars[6] = ' ';

            System.out.println(str1 == str2);
            System.out.println(str1);
            System.out.println(str2);           
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }
}

输出

true
I am   mutable
I am   mutable

虽然java试图忽略它，str只不过是一个指针。这意味着当你第一次写str = "Hello";时，你创建了一个str指向的对象。当你通过写str = "Help!";来重新赋值str时，一个新对象被创建，旧的"Hello"对象在java需要的时候被垃圾收集。

字符串类是不可变的，你不能改变不可变对象的值。 但在String的情况下，如果你改变了String的值，它会在字符串池中创建新的字符串，而不是旧的字符串引用。通过这种方式，字符串是不可变的。 举个例子，

String str = "Mississippi";  
System.out.println(str); // prints Mississippi 

它将创建一个字符串“Mississippi”，并将其添加到字符串池 所以现在str指向密西西比。

str = str.replace("i", "!");  
System.out.println(str); // prints M!ss!ss!pp! 

但经过上述操作， 另一个字符串将被创建"M!ss!ss!pp!" 它将被添加到String池。而且 现在str指向M!ss!ss!pp!而不是密西西比州。

通过这种方式，当你改变string对象的值时，它会创建一个新的对象并将其添加到string池中。

让我们再看一个例子

String s1 = "Hello"; 
String s2 = "World"; 
String s = s1 + s2;

上面的3行代码将向字符串池中添加3个字符串对象。 1)你好 2)世界 3) HelloWorld

这里的不可变性意味着实例可以指向其他引用，但字符串的原始内容不会在原始引用处被修改。 让我用你举的第一个例子来解释。 第一个str指向“Hello”，这是可以的。 第二次它指向“救命!”。 这里str开始指向“Help!”，“Hello”字符串的引用丢失了，我们无法恢复。

事实上，当str试图修改现有内容时，将生成另一个新字符串，str将开始指向该引用。 所以我们看到，在原始引用处的字符串没有被修改，但在它的引用处是安全的，对象的实例开始指向不同的引用，所以不变性是保留的。

STR不是一个对象，而是一个对象的引用。“Hello”和“Help!”是两个不同的String对象。因此，str指向一个字符串。你可以改变它指向的东西，但不能改变它指向的东西。

以下面的代码为例:

String s1 = "Hello";
String s2 = s1;
// s1 and s2 now point at the same string - "Hello"

现在，我们对s1做什么都不会影响s2的值。它们引用同一个对象——字符串“Hello”——但该对象是不可变的，因此不能被修改。

如果我们这样做:

s1 = "Help!";
System.out.println(s2); // still prints "Hello"

这里我们看到了改变对象和改变引用之间的区别。S2仍然指向我们最初设置s1所指向的对象。将s1设置为“Help!”只会改变引用，而它最初引用的String对象保持不变。

如果字符串是可变的，我们可以这样做:

String s1 = "Hello";
String s2 = s1;
s1.setCharAt(1, 'a'); // Fictional method that sets character at a given pos in string
System.out.println(s2); // Prints "Hallo"

编辑以回应OP的编辑:

如果你看一下String.replace(char,char)的源代码(也可以在JDK安装目录的src.zip中找到——一个专业的提示是，当你想知道某些东西是如何工作的时候，可以查看那里)，你可以看到它所做的如下所示:

如果当前字符串中出现了一次或多次oldChar，则复制当前字符串，其中所有出现的oldChar都被newChar替换。 如果oldChar在当前字符串中不存在，则返回当前字符串。

所以，是的，“密西西比”。replace('i'， '!')创建一个新的String对象。同样，以下观点成立:

String s1 = "Mississippi";
String s2 = s1;
s1 = s1.replace('i', '!');
System.out.println(s1); // Prints "M!ss!ss!pp!"
System.out.println(s2); // Prints "Mississippi"
System.out.println(s1 == s2); // Prints "false" as s1 and s2 are two different objects

你现在的作业是看看如果你改变s1 = s1，上面的代码会做什么。替换(“我”、“!”);到s1 = s1。替换(“问”、“!”);：）

1实际上，改变字符串(和其他不可变对象)是可能的。它需要反思，而且非常非常危险，永远不应该使用，除非你真的有兴趣破坏程序。