Java字符串真的不可变吗？

我们都知道这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 是不可变的*，但这仅意味着您无法使用其公共API对其进行更改。

您在这里所做的是使用反射来绕过常规API。同样，您可以更改枚举的值，更改整数自动装箱中使用的查找表等。

现在，原因s1和s2更改值是它们都引用相同的实习字符串。编译器执行此操作（如其他答案所述）。

原因s3实际上并不令我惊讶，因为我认为它可以共享value数组（它在Java的较早版本中（在Java 7u6之前）已完成）。但是，查看的源代码String，我们可以看到value实际上已复制了子字符串的字符数组（使用Arrays.copyOfRange(..)）。这就是为什么它保持不变。

您可以安装SecurityManager，以避免恶意代码执行此类操作。但是请记住，某些库依赖于使用这种反射技巧（通常是ORM工具，AOP库等）。

*）我最初写道Strings并不是真正不变的，只是“有效的不变”。这可能会在的当前实现中产生误导String，其中value确实标记了数组private final。但是，仍然值得注意的是，没有办法在Java中将数组声明为不可变的，因此，即使使用适当的访问修饰符，也必须注意不要将其暴露在类之外。

由于该主题似乎非常受欢迎，因此，建议您进一步阅读以下内容：Heinz Kabutz在JavaZone 2009上发表的《 Reflection Madness》演讲，其中涵盖了OP中的许多问题以及其他反思……嗯……疯狂。

它涵盖了为什么有时有用。为什么，在大多数情况下，您应该避免使用它。:-)

在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);

因此，对此进行更改将更改持有指向它的指针的字符串，但是s3由于substring()不会更改，因此使用新字符串创建的字符串也不会更改。

您正在使用反射来规避String的不变性-这是“攻击”的一种形式。

您可以创建许多这样的示例（例如，您甚至可以实例化一个Void对象），但这并不意味着String不是“不可变的”。

在某些情况下，这种类型的代码可以为您带来好处，并且是“良好的编码”，例如，尽早（在GC之前）从内存中清除密码。

根据安全管理器的不同，您可能无法执行代码。

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

可见性修饰符和最终修饰符（即不变性）并不是针对Java中恶意代码的度量；它们仅仅是防止错误并使代码更易于维护的工具（系统的最大卖点之一）。这就是为什么您可以String通过反射访问内部实现细节（例如的后备char数组）的原因。

您看到的第二个效果是，所有String的事物都在改变，而好像您只是在改变s1。Java String文字的某些属性是它们会自动进行intern（即缓存）。具有相同值的两个String文字实际上将是同一对象。当您使用new它创建一个String时，它不会被自动检查，也不会看到这种效果。

#substring直到最近（Java 7u6）都以类似的方式工作，这将在问题的原始版本中解释这种行为。它没有创建一个新的支持char数组，而是重用了原始String中的那个数组。它只是创建了一个新的String对象，该对象使用一个偏移量和一个长度来仅表示该数组的一部分。通常，这是因为Strings是不可变的-除非您对此进行规避。此属性#substring还意味着，当仍然存在从原始字符串创建的较短子字符串时，无法对整个原始字符串进行垃圾回收。

从当前的Java和当前版本的问题开始，没有奇怪的行为#substring。

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

s1和s2都被更改，因为它们都分配给了相同的“ intern” String实例。您可以从本文中有关字符串相等和实习的那部分中找到更多信息。您可能会惊讶地发现在示例代码中，s1 == s2 return true！

您正在使用哪个Java版本？从Java 1.7.0_06起，Oracle更改了String的内部表示形式，尤其是子字符串。

引用Oracle调整Java的内部字符串表示形式：

在新的范例中，字符串偏移量和计数字段已删除，因此子字符串不再共享基础char []值。

有了此更改，它可能会在没有反射的情况下发生（???）。

这里确实有两个问题：

1. 字符串真的是不变的吗？
2. 为什么s3不变？

要点1：除ROM外，您的计算机中没有不变的内存。如今，有时ROM也可写。总是有一些代码可以写到您的内存地址（无论是内核代码还是本机代码都避开了托管环境）。因此，在“现实”中，没有，它们不是绝对不变的。

要点2：这是因为子字符串可能正在分配一个新的字符串实例，这很可能会复制该数组。可以以不会复制的方式实现子字符串，但这并不意味着它会这样做。需要权衡。

例如，应该引用 reallyLargeString.substring(reallyLargeString.length - 2)使大量内存保持活动状态，还是仅保留几个字节？

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

无论如何，您的JVM似乎选择对子字符串调用使用深拷贝。

要补充@haraldK的答案-这是一个安全漏洞，可能会对应用程序造成严重影响。

第一件事是对存储在字符串池中的常量字符串的修改。当string声明为a时String s = "Hello World";，它被放入一个特殊的对象池中以供进一步重用。问题在于，编译器将在编译时放置对修改后的版本的引用，并且一旦用户在运行时修改了存储在此池中的字符串，代码中的所有引用都将指向修改后的版本。这将导致以下错误：

System.out.println("Hello World"); 

将打印：

Hello Java!

当我在如此高风险的字符串上执行大量计算时，我遇到了另一个问题。在计算过程中，每100万次错误中有1次发生了错误，因此结果不确定。我可以通过关闭JIT来找到问题-在关闭JIT的情况下，我总是得到相同的结果。我的猜测是，原因是此String安全黑客破坏了一些JIT优化合同。

根据池的概念，所有包含相同值的String变量都将指向相同的内存地址。因此，s1和s2都包含相同的“ Hello World”值，它们将指向相同的存储位置（例如M1）。

另一方面，s3包含“世界”，因此它将指向不同的内存分配（例如M2）。

所以现在发生的是，正在更改S1的值（通过使用char []值）。因此，由s1和s2指向的存储位置M1的值已更改。

因此，结果，存储器位置M1已经被修改，这导致s1和s2的值改变。

但是位置M2的值保持不变，因此s3包含相同的原始值。

s3实际上没有改变的原因是因为在Java中，当您执行子字符串操作时，会在内部复制子字符串的值字符数组（使用Arrays.copyOfRange（））。

s1和s2是相同的，因为在Java中它们都引用相同的内部字符串。它是用Java设计的。

String是不可变的，但是通过反射，您可以更改String类。您刚刚将String类重新定义为实时可变的。如果需要，可以将方法重新定义为公共，私有或静态。

[免责声明，这是一种故意为之作答的答案，因为我认为更“不在家做孩子”的答案是必要的]

罪过是field.setAccessible(true);通过允许访问私有字段来违反公共api 的行。那是一个巨大的安全漏洞，可以通过配置安全管理器将其锁定。

问题中的现象是实现细节，当您不使用该危险代码行通过反射违反访问修饰符时，您将永远看不到实现细节。显然，两个（通常）不可变字符串可以共享同一char数组。子字符串是否共享同一数组取决于它是否可以以及开发人员是否考虑共享它。通常，这些是看不见的实现细节，除非您使用该行代码从头开始访问访问修饰符，否则就不必知道这些细节。

依靠这样的细节根本不是一个好主意，如果不使用反射违反访问修饰符，就无法体验这些细节。该类的所有者仅支持普通的公共API，以后可以自由更改实现。

说了这么多，当您拿着枪抬起头来迫使您执行此类危险的事情时，代码行确实非常有用。使用该后门通常是一种代码味道，您需要将其升级到不必犯错的更好的库代码。该危险代码行的另一个常见用法是编写“伏都教框架”（orm，注入容器等）。许多人对这样的框架（包括赞成和反对）都抱有宗教信仰，因此我将避免激怒战争，除了绝大多数程序员不必去那里之外，别无其他。

在JVM堆内存的永久区域中创建字符串。因此，是的，它确实是不可变的，创建后就无法更改。因为在JVM中，堆内存有三种类型：1.年轻的一代2.老的一代3.永久的一代。

创建任何对象时，它将进入为字符串池保留的年轻代堆区域和PermGen区域。

您可以从这里获取更多详细信息，并从中获取更多信息： 垃圾回收如何在Java中工作。

String本质上是不可变的，因为没有方法可以修改String对象。这就是他们引入StringBuilder和StringBuffer类的原因