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

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

看看这个:

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中打破字符串不变性的人…

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赋一个新值时，你没有改变它引用的对象的值，你引用的是一个不同的对象。

超级晚的答案，但想把一个简洁的消息从作者的String类在Java

字符串是常量;它们的值在被修改之后就不能再修改了 创建。字符串缓冲区支持可变字符串。因为字符串 对象是不可变的，它们可以被共享。

它可以从这个文档中导出，任何改变字符串的东西，都会返回不同的对象(可以是新的或旧的)。 关于这一点不那么微妙的提示应该来自函数签名。 想想看，为什么他们让一个对象上的函数返回一个对象而不是状态?

public String replace(char oldChar, char newChar) 

还有一个来源使这种行为显式(从替换函数文档)

返回一个新字符串，该字符串由替换所有出现的 oldChar和newChar。

来源:https://docs.oracle.com/javase/7/docs/api/java/lang/String.html取代(char、% 20字符)

作者李·博因顿 作者阿瑟·范霍夫 作者马丁·布赫兹 作者乌尔夫·齐比斯

来源:JavaDoc of String。

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

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

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

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

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

我可以说，不可变性是你不能改变字符串本身。假设你有字符串x，它的值是“abc”。现在您不能更改字符串，也就是说，您不能更改“abc”中的任何字符/s。

如果你必须改变字符串中的任何字符，你可以使用一个字符数组并改变它或使用StringBuilder。

String x = "abc";
x = "pot";
x = x + "hj";
x = x.substring(3);
System.out.println(x);

char x1[] = x.toCharArray();
x1[0] = 's';
String y = new String(x1);
System.out.println(y);

输出:

hj
sj