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

事实上，当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

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

我建议你读一读《Cup Size》——一个关于变量和值传递的故事(续《Cup Size》)。这对阅读上面的文章有很大帮助。

你读过吗?是的。好。

String str = new String();

这将创建一个名为“str”的新“远程控制”，并将其设置为值new String()(或“”)。

例如，在内存中创建:

str --- > ""

str  = "Hello";

这将更改远程控制“str”，但不会修改原始字符串“”。

例如，在内存中创建:

str -+   ""
     +-> "Hello"

str = "Help!";

这将更改远程控件“str”，但不会修改原始字符串“”或远程控件当前指向的对象。

例如，在内存中创建:

str -+   ""
     |   "Hello"
     +-> "Help!"

就像莱纳斯·托瓦兹说的:

空谈是廉价的。给我看看代码

看看这个:

public class Test{
    public static void main(String[] args){

        String a = "Mississippi";
        String b = "Mississippi";//String immutable property (same chars sequence), then same object

        String c = a.replace('i','I').replace('I','i');//This method creates a new String, then new object
        String d = b.replace('i','I').replace('I','i');//At this moment we have 3 String objects, a/b, c and d

        String e = a.replace('i','i');//If the arguments are the same, the object is not affected, then returns same object

        System.out.println( "a==b? " + (a==b) ); // Prints true, they are pointing to the same String object

        System.out.println( "a: " + a );
        System.out.println( "b: " + b );

        System.out.println( "c==d? " + (c==d) ); // Prints false, a new object was created on each one

        System.out.println( "c: " + c ); // Even the sequence of chars are the same, the object is different
        System.out.println( "d: " + d );

        System.out.println( "a==e? " + (a==e) ); // Same object, immutable property
    }
}

输出为

a==b? true
a: Mississippi
b: Mississippi
c==d? false
c: Mississippi
d: Mississippi
a==e? true

所以，记住两件事:

字符串是不可变的，直到你应用一个方法来操作和创建一个新的字符串(c和d的情况)。 如果两个参数相同，则Replace方法返回相同的String对象

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