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

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

看看这个:

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对象

字符串不会改变，但对它的引用会改变。你混淆了不可变性和final字段的概念。如果一个字段被声明为final，那么一旦它被赋值，就不能重新赋值。

对于那些想知道如何在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中的String在Immutable和Final中只是意味着它不能被更改或修改:

案例1:

class TestClass{  
 public static void main(String args[]){  
   String str = "ABC";  
   str.concat("DEF");  
   System.out.println(str);  
 }  
} 

输出:美国广播公司(ABC) 原因:对象引用str没有改变，实际上是一个新对象 在池中创建了“DEF”，它根本没有引用 (也就是失去了)。

案例2:

class TestClass{  
 public static void main(String args[]){  
   String str="ABC";  
   str=str.concat("DEF");  
   System.out.println(str);  
 }  
}  

输出:六边形ABCDEF 原因:在这种情况下，str现在引用一个新对象“ABCDEF” 因此它打印ABCDEF，即前一个str对象“ABC”在池中丢失，没有引用。

如果HELLO是你的字符串，那么你不能把HELLO改成HILLO。这个性质叫做不可变性。

你可以有多个指针字符串变量指向HELLO字符串。

但是如果HELLO是char Array，那么你可以将HELLO改为HILLO。例如,

char[] charArr = 'HELLO';
char[1] = 'I'; //you can do this

编程语言具有不可变的数据变量，因此可以作为键、值对中的键使用。

在Java中，对象通常是通过引用访问的。在你的代码段中，str是一个引用，它首先被赋值给“Hello”(一个自动创建的对象或从常量池中获取的对象)，然后你将另一个对象“Help!”赋值给同一个引用。需要注意的一点是，引用是相同的，但对象是不同的。代码中还有一件事，你访问了三个对象，

当你调用new String()。 当你分配"hello"的时候。 当你说“救命!”

调用new String()会创建一个新对象，即使它存在于字符串池中，所以通常不应该使用它。要将new string()创建的字符串放入字符串池，可以尝试intern()方法。

我希望这能有所帮助。