在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，因此它不会更改。

这是一个快速指南的一切

        // Character array
        char[] chr = {'O', 'K', '!'};

        // this is String class
        String str1 = new String(chr);
        
        // this is concat
        str1 = str1.concat("another string's ");
        
        // this is format
        System.out.println(String.format(str1 + " %s ", "string"));
        
        // this is equals
        System.out.println(str1.equals("another string"));

        //this is split
        for(String s: str1.split(" ")){
            System.out.println(s);
        }

        // this is length
        System.out.println(str1.length());

        //gives an score of the total change in the length
        System.out.println(str1.compareTo("OK!another string string's"));

        // trim
        System.out.println(str1.trim());

        // intern
        System.out.println(str1.intern());

        // character at
        System.out.println(str1.charAt(5));

        // substring
        System.out.println(str1.substring(5, 12));

        // to uppercase
        System.out.println(str1.toUpperCase());

        // to lowerCase
        System.out.println(str1.toLowerCase());

        // replace
        System.out.println(str1.replace("another", "hello"));

       //   output

        // OK!another string's  string 
        // false
        // OK!another
        // string's
        // 20
        // 7
        // OK!another string's
        // OK!another string's 
        // o
        // other s
        // OK!ANOTHER STRING'S 
        // ok!another string's 
        // OK!hello string's 

您正在使用反射来访问字符串对象的“实现细节”。不可变性是对象的公共接口的特性。

[免责声明，这是一个故意固执己见的回答风格，因为我觉得一个更“不要在家里这样做，孩子们”的回答是有保证的]

sin是line field.setAccessible(true);它说通过允许访问私有字段来违反公共API。这是一个巨大的安全漏洞，可以通过配置一个安全管理器来锁定。

The phenomenon in the question are implementation details which you would never see when not using that dangerous line of code to violate the access modifiers via reflection. Clearly two (normally) immutable strings can share the same char array. Whether a substring shares the same array depends on whether it can and whether the developer thought to share it. Normally these are invisible implementation details which you should not have to know unless you shoot the access modifier through the head with that line of code.

依赖这些细节并不是一个好主意，因为如果不违反使用反射的访问修饰符就无法体验这些细节。该类的所有者只支持普通的公共API，并且可以在将来自由地进行实现更改。

Having said all that the line of code is really very useful when you have a gun held you your head forcing you to do such dangerous things. Using that back door is usually a code smell that you need to upgrade to better library code where you don't have to sin. Another common use of that dangerous line of code is to write a "voodoo framework" (orm, injection container, ...). Many folks get religious about such frameworks (both for and against them) so I will avoid inviting a flame war by saying nothing other than the vast majority of programmers don't have to go there.

字符串不可变性是从接口的角度来看的。您使用反射绕过接口，直接修改String实例的内部结构。

s1和s2都被改变了，因为它们都被分配给了同一个“intern”String实例。您可以从这篇关于字符串相等和实习的文章中找到更多关于这部分的内容。您可能会惊讶地发现，在示例代码中，s1 == s2返回true!

这里有两个问题:

字符串真的是不可变的吗? 为什么s3没有改变?

第一点:除了ROM，在你的计算机中没有不可变的内存。现在甚至ROM有时也是可写的。总有一些代码(无论是绕过托管环境的内核代码还是本机代码)可以写入内存地址。所以，在“现实”中，它们不是绝对不变的。

对于第2点:这是因为substring可能分配了一个新的字符串实例，这可能是复制数组。substring有可能以不复制的方式实现，但这并不意味着它会这样做。这涉及到权衡。

例如，应该持有对reallyLargeString.substring(reallyLargeString. substring)的引用。长度- 2)导致大量的内存保持活跃，还是只有几个字节?

这取决于substring如何实现。深度复制将保留较少的活动内存，但运行速度会稍微慢一些。浅拷贝可以保留更多的内存，但速度更快。使用深度拷贝还可以减少堆碎片，因为字符串对象及其缓冲区可以分配在一个块中，而不是两个单独的堆分配。

在任何情况下，看起来您的JVM都选择对子字符串调用使用深度拷贝。