关于你问题的替换部分，试试这个:

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

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

对于那些想知道如何在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

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

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

    public final class String_Test {

    String name;
    List<String> list=new ArrayList<String>();

    public static void main(String[] args) {

        String_Test obj=new String_Test();
        obj.list.add("item");//List will point to a memory unit- i.e will have one Hashcode value #1234

        List<String> list2=obj.list; //lis1 also will point to same #1234

        obj.list.add("new item");//Hashcode of list is not altered- List is mutable, so reference remains same, only value in that memory location changes

        String name2=obj.name="Myname"; // name2 and name will point to same instance of string -Hashcode #5678
        obj.name = "second name";// String is Immutable- New String HAI is created and name will point to this new instance- bcoz of this Hashcode changes here #0089

        System.out.println(obj.list.hashCode());
        System.out.println(list2.hashCode());
        System.out.println(list3.hashCode());

        System.out.println("===========");
        System.out.println(obj.name.hashCode());
        System.out.println(name2.hashCode());
    }
}

会产生这样的东西吗

1419358369 1419358369

103056 65078777

不可变对象的目的是它的值一旦被赋值就不应该被改变。 它将返回新对象，每次你试图改变它基于实现。 注意:可以使用Stringbuffer而不是string来避免这种情况。

对于你的最后一个问题::u将有一个引用，在字符串池中有2个字符串。 除了参考将指向m!ss!ss!pp!

字符串是不可变的，这意味着你不能改变对象本身，但是你可以改变对对象的引用。当你调用a = "ty"时，你实际上是将a的引用更改为一个由String文字"ty"创建的新对象。改变一个对象意味着使用它的方法来改变它的一个字段(或者字段是公共的而不是final的，这样它们就可以从外部更新而不需要通过方法访问它们)，例如:

Foo x = new Foo("the field");
x.setField("a new field");
System.out.println(x.getField()); // prints "a new field"

而在一个不可变类(声明为final，以防止通过继承修改)(它的方法不能修改它的字段，而且字段总是私有的，建议是final)，例如String，你不能改变当前的String，但你可以返回一个新的String，即:

String s = "some text";
s.substring(0,4);
System.out.println(s); // still printing "some text"
String a = s.substring(0,4);
System.out.println(a); // prints "some"