我们都知道String在Java中是不可变的，但是检查下面的代码:
String s1 = "Hello World";
String s2 = "Hello World";
String s3 = s1.substring(6);
System.out.println(s1); // Hello World
System.out.println(s2); // Hello World
System.out.println(s3); // World
Field field = String.class.getDeclaredField("value");
field.setAccessible(true);
char[] value = (char[])field.get(s1);
value[6] = 'J';
value[7] = 'a';
value[8] = 'v';
value[9] = 'a';
value[10] = '!';
System.out.println(s1); // Hello Java!
System.out.println(s2); // Hello Java!
System.out.println(s3); // World
为什么这个程序是这样运行的?为什么s1和s2的值变了，而s3的值不变?
根据池化的概念，所有包含相同值的String变量将指向相同的内存地址。因此，s1和s2都包含相同的" Hello World "值，将指向相同的内存位置(例如M1)。
另一方面，s3包含“World”，因此它将指向不同的内存分配(比如M2)。
所以现在所发生的是S1的值被改变了(通过使用char[]值)。因此，由s1和s2指向的内存位置M1的值被改变了。
因此，内存位置M1被修改，导致s1和s2的值发生变化。
但是位置M2的值保持不变，因此s3包含相同的原始值。
在Java中，如果两个字符串基元变量被初始化为相同的字面值，它会将相同的引用赋给这两个变量:
String Test1="Hello World";
String Test2="Hello World";
System.out.println(test1==test2); // true
这就是比较返回true的原因。第三个字符串是使用substring()创建的，它创建了一个新的字符串，而不是指向相同的字符串。
当你使用反射访问一个字符串时，你会得到实际的指针:
Field field = String.class.getDeclaredField("value");
field.setAccessible(true);
因此，更改this将更改持有指向它的指针的字符串，但由于substring()使用新字符串创建了s3，因此它不会更改。
可见性修饰符和final(即不可变性)不是针对Java中的恶意代码的度量;它们仅仅是防止出现错误并使代码更具可维护性的工具(这是系统的一大卖点)。这就是为什么您可以通过反射访问内部实现细节，例如字符串的支持字符数组。
你看到的第二个效果是所有的字符串都改变了，而看起来你只改变了s1。它是Java字符串字面量的一个特定属性，它们被自动存储，即缓存。两个具有相同值的String字面值实际上是同一个对象。当你用new创建一个String时，它不会自动被实习生，你也不会看到这个效果。
#substring until recently (Java 7u6) worked in a similar way, which would have explained the behaviour in the original version of your question. It didn't create a new backing char array but reused the one from the original String; it just created a new String object that used an offset and a length to present only a part of that array. This generally worked as Strings are immutable - unless you circumvent that. This property of #substring also meant that the whole original String couldn't be garbage collected when a shorter substring created from it still existed.
在当前的Java和当前版本的问题中，#substring没有奇怪的行为。
这里有两个问题:
字符串真的是不可变的吗?
为什么s3没有改变?
第一点:除了ROM，在你的计算机中没有不可变的内存。现在甚至ROM有时也是可写的。总有一些代码(无论是绕过托管环境的内核代码还是本机代码)可以写入内存地址。所以，在“现实”中，它们不是绝对不变的。
对于第2点:这是因为substring可能分配了一个新的字符串实例，这可能是复制数组。substring有可能以不复制的方式实现，但这并不意味着它会这样做。这涉及到权衡。
例如，应该持有对reallyLargeString.substring(reallyLargeString. substring)的引用。长度- 2)导致大量的内存保持活跃，还是只有几个字节?
这取决于substring如何实现。深度复制将保留较少的活动内存，但运行速度会稍微慢一些。浅拷贝可以保留更多的内存，但速度更快。使用深度拷贝还可以减少堆碎片，因为字符串对象及其缓冲区可以分配在一个块中，而不是两个单独的堆分配。
在任何情况下，看起来您的JVM都选择对子字符串调用使用深度拷贝。
根据池化的概念，所有包含相同值的String变量将指向相同的内存地址。因此，s1和s2都包含相同的" Hello World "值，将指向相同的内存位置(例如M1)。
另一方面，s3包含“World”，因此它将指向不同的内存分配(比如M2)。
所以现在所发生的是S1的值被改变了(通过使用char[]值)。因此，由s1和s2指向的内存位置M1的值被改变了。
因此，内存位置M1被修改，导致s1和s2的值发生变化。
但是位置M2的值保持不变，因此s3包含相同的原始值。
