什么是 Java 字符串实习？

Question

什么是 Java 中的字符串实习，我应该何时使用它，为什么？

Answer 1

http://docs.oracle.com/javase/7/docs/api/java/lang/String.html#intern()

基本上对一系列字符串执行 String.intern() 将确保所有具有相同内容的字符串共享相同的内存。 因此，如果您有 'john' 出现 1000 次的姓名列表，通过实习，您可以确保只有一个 'john' 实际分配了内存。

这对于减少程序的内存需求很有用。 但请注意，缓存由 JVM 在永久内存池中维护，与堆相比，永久内存池的大小通常有限，因此如果您没有太多重复值，则不应使用实习生。

---

更多关于使用 intern() 的内存限制

一方面，确实可以通过内部化来删除 String 重复项。 问题是内部化的字符串进入永久代，这是 JVM 的一个区域，为非用户对象保留，如类、方法和其他内部 JVM 对象。 这个区域的大小是有限的，通常比堆小很多。 对 String 调用 intern() 具有将其从堆移出到永久代的效果，并且可能会耗尽 PermGen 空间。

-- 来自： http : //www.codeinstructions.com/2009/01/busting-javalangstringintern-myths.html

---

从 JDK 7（我的意思是在 HotSpot 中）开始，发生了一些变化。

在 JDK 7 中，interned 字符串不再分配在 Java 堆的永久代中，而是与应用程序创建的其他对象一起分配在 Java 堆的主要部分（称为年轻代和年老代）中. 此更改将导致更多数据驻留在主 Java 堆中，而永久代中的数据更少，因此可能需要调整堆大小。 由于此更改，大多数应用程序只会看到相对较小的堆使用差异，但加载许多类或大量使用 String.intern() 方法的较大应用程序将看到更显着的差异。

-- 来自Java SE 7 的特性和增强

更新：从 Java 7 开始，实习字符串存储在主堆中。 http://www.oracle.com/technetwork/java/javase/jdk7-relnotes-418459.html#jdk7changes

Answer 2

有一些“引人入胜的面试”问题，比如你为什么得到平等！ 如果您执行以下代码。

String s1 = "testString";
String s2 = "testString";
if(s1 == s2) System.out.println("equals!");

如果你想比较字符串，你应该使用equals() 。 上面将打印 equals，因为testString已经由编译器为您实习。 您可以使用实习生方法自己实习字符串，如之前的答案所示....

Answer 3

JLS

JLS 7 3.10.5 对其进行了定义并给出了一个实际示例：

此外，字符串字面量始终引用类 String 的同一个实例。 这是因为字符串文字 - 或者更一般地说，作为常量表达式（第 15.28 节）的值的字符串 - 使用 String.intern 方法被“嵌入”以便共享唯一实例。

例 3.10.5-1。 字符串文字

由编译单元（§7.3）组成的程序：

 package testPackage; class Test { public static void main(String[] args) { String hello = "Hello", lo = "lo"; System.out.print((hello == "Hello") + " "); System.out.print((Other.hello == hello) + " "); System.out.print((other.Other.hello == hello) + " "); System.out.print((hello == ("Hel"+"lo")) + " "); System.out.print((hello == ("Hel"+lo)) + " "); System.out.println(hello == ("Hel"+lo).intern()); } } class Other { static String hello = "Hello"; }

和编译单元：

 package other; public class Other { public static String hello = "Hello"; }

产生输出：

 true true true true false true

虚拟机

JVMS 7 5.1 说实习是通过专用的CONSTANT_String_info结构神奇而有效地实现的（与大多数其他具有更通用表示的对象不同）：

字符串字面量是对 String 类实例的引用，从类或接口的二进制表示中的 CONSTANT_String_info 结构（第 4.4.3 节）派生而来。 CONSTANT_String_info 结构给出了构成字符串文字的 Unicode 代码点序列。

Java 编程语言要求相同的字符串文字（即包含相同代码点序列的文字）必须引用类 String 的相同实例（JLS §3.10.5）。 此外，如果在任何字符串上调用 String.intern 方法，则结果是对同一类实例的引用，如果该字符串作为文字出现，则将返回该类实例。 因此，以下表达式的值必须为 true：

 ("a" + "b" + "c").intern() == "abc"

为了派生字符串文字，Java 虚拟机检查由 CONSTANT_String_info 结构给出的代码点序列。

• 如果之前在类 String 的实例上调用了方法 String.intern，该实例包含与 CONSTANT_String_info 结构给出的相同的 Unicode 代码点序列，则字符串文字派生的结果是对同一个类 String 实例的引用。

• 否则，将创建一个新的 String 类实例，其中包含由 CONSTANT_String_info 结构给出的 Unicode 代码点序列； 对该类实例的引用是字符串文字派生的结果。 最后，调用新 String 实例的 intern 方法。

字节码

让我们反编译一些 OpenJDK 7 字节码，看看实习的效果。

如果我们反编译：

public class StringPool {
    public static void main(String[] args) {
        String a = "abc";
        String b = "abc";
        String c = new String("abc");
        System.out.println(a);
        System.out.println(b);
        System.out.println(a == c);
    }
}

我们在常量池上有：

#2 = String             #32   // abc
[...]
#32 = Utf8               abc

和main ：

 0: ldc           #2          // String abc
 2: astore_1
 3: ldc           #2          // String abc
 5: astore_2
 6: new           #3          // class java/lang/String
 9: dup
10: ldc           #2          // String abc
12: invokespecial #4          // Method java/lang/String."<init>":(Ljava/lang/String;)V
15: astore_3
16: getstatic     #5          // Field java/lang/System.out:Ljava/io/PrintStream;
19: aload_1
20: invokevirtual #6          // Method java/io/PrintStream.println:(Ljava/lang/String;)V
23: getstatic     #5          // Field java/lang/System.out:Ljava/io/PrintStream;
26: aload_2
27: invokevirtual #6          // Method java/io/PrintStream.println:(Ljava/lang/String;)V
30: getstatic     #5          // Field java/lang/System.out:Ljava/io/PrintStream;
33: aload_1
34: aload_3
35: if_acmpne     42
38: iconst_1
39: goto          43
42: iconst_0
43: invokevirtual #7          // Method java/io/PrintStream.println:(Z)V

注意方法：

• 0和3 ：加载相同的ldc #2常量（文字）
• 12 ：创建一个新的字符串实例（以#2作为参数）
• 35 : a和c作为常规对象与if_acmpne进行比较

常量字符串的表示在字节码上非常神奇：

• 它有一个专用的CONSTANT_String_info结构，不同于常规对象（例如new String ）
• 该结构指向包含数据的CONSTANT_Utf8_info 结构。 这是表示字符串的唯一必要数据。

上面的 JVMS 引用似乎是说，只要指向的 Utf8 相同，那么ldc加载相同的实例。

我对字段进行了类似的测试，并且：

• static final String s = "abc"通过ConstantValue 属性指向常量表
• 非最终字段没有该属性，但仍可以使用ldc进行初始化

结论：字符串池有直接字节码支持，内存表示高效。

奖励：将其与Integer pool进行比较，后者没有直接的字节码支持（即没有CONSTANT_String_info类似物）。

Answer 4

针对 Java 8 或 plus 的更新。 在 Java 8 中，PermGen（永久代）空间被移除并被元空间取代。 String 池内存被移动到 JVM 的堆中。

与 Java 7 相比，在堆中增加了 String 池大小。 因此，内部化字符串有更多空间，但整个应用程序的内存较少。

还有一件事，你已经知道在Java中比较2个（引用）对象时，' == '用于比较对象的引用，' equals '用于比较对象的内容。

让我们检查一下这段代码：

String value1 = "70";
String value2 = "70";
String value3 = new Integer(70).toString();

结果：

value1 == value2 ---> 真

value1 == value3 ---> 假

value1.equals(value3) ---> true

value1 == value3.intern() ---> 真

这就是为什么您应该使用“ equals ”来比较 2 个 String 对象的原因。 这就是intern()的用处。

Answer 5

由于字符串是对象，而且 Java 中的所有对象始终只存储在堆空间中，因此所有字符串都存储在堆空间中。 但是，Java 将在未使用 new 关键字的情况下创建的字符串保存在堆空间的一个特殊区域中，该区域称为“字符串池”。 Java 将使用 new 关键字创建的字符串保存在常规堆空间中。

字符串池的目的是维护一组唯一的字符串。 任何时候不使用 new 关键字创建新字符串时，Java 都会检查字符串池中是否已存在相同的字符串。 如果是，Java 返回对同一个 String 对象的引用，如果不是，Java 在字符串池中创建一个新的 String 对象并返回其引用。 因此，例如，如果您在代码中使用字符串“hello”两次，如下所示，您将获得对同一字符串的引用。 我们可以通过使用==运算符比较两个不同的引用变量来实际测试这个理论，如下面的代码所示：

String str1 = "hello";
String str2 = "hello";
System.out.println(str1 == str2); //prints true

String str3 = new String("hello");
String str4 = new String("hello");

System.out.println(str1 == str3); //prints false
System.out.println(str3 == str4); //prints false 

==运算符只是检查两个引用是否指向同一个对象，如果指向则返回 true。 在上面的代码中， str2获取对之前创建的同一个 String 对象的引用。 但是， str3和str4获得对两个完全不同的 String 对象的引用。 这就是为什么str1 == str2返回 true 但str1 == str3和str3 == str4返回 false 的原因。 事实上，当你做new String("hello"); 如果这是第一次在程序的任何地方使用字符串“hello”，则会创建两个 String 对象，而不是一个，一个在字符串池中，因为使用了带引号的字符串，一个在常规堆空间中，因为new 关键字的使用。

字符串池是 Java 通过避免创建多个包含相同值的 String 对象来节省程序内存的方式。 可以通过使用 String 的 intern 方法从使用 new 关键字创建的字符串的字符串池中获取字符串。 它被称为字符串对象的“实习”。 例如，

String str1 = "hello";
String str2 = new String("hello");
String str3 = str2.intern(); //get an interned string obj

System.out.println(str1 == str2); //prints false
System.out.println(str1 == str3); //prints true

OCP Java SE 11 程序员，Deshmukh

Answer 6

字符串实习是编译器的一种优化技术。 如果在一个编译单元中有两个相同的字符串文字，那么生成的代码将确保只为程序集中该文字的所有实例（用双引号括起来的字符）创建一个字符串对象。

我来自 C# 背景，所以我可以通过举一个例子来解释：

object obj = "Int32";
string str1 = "Int32";
string str2 = typeof(int).Name;

以下比较的输出：

Console.WriteLine(obj == str1); // true
Console.WriteLine(str1 == str2); // true    
Console.WriteLine(obj == str2); // false !?

注1 ：对象通过引用进行比较。

Note2 :typeof(int).Name 是通过反射方法计算的，所以它不会在编译时计算。 这里的这些比较是在编译时进行的。

结果分析： 1) 正确，因为它们都包含相同的文字，因此生成的代码将只有一个对象引用“Int32”。 见注 1 。

2) true 因为检查了两个值的内容是相同的。

3) FALSE 因为 str2 和 obj 没有相同的文字。 见注 2 。

Answer 7

Java interning() method basically makes sure that if String object is present in SCP, If yes then it returns that object and if not then creates that objects in SCP and return its references

for eg: String s1=new String("abc");
        String s2="abc";
        String s3="abc";

s1==s2// false, because 1 object of s1 is stored in heap and other in scp(but this objects doesn't have explicit reference) and s2 in scp
s2==s3// true

now if we do intern on s1
s1=s1.intern() 

//JVM checks if there is any string in the pool with value “abc” is present? Since there is a string object in the pool with value “abc”, its reference is returned.
Notice that we are calling s1 = s1.intern(), so the s1 is now referring to the string pool object having value “abc”.
At this point, all the three string objects are referring to the same object in the string pool. Hence s1==s2 is returning true now.

Answer 8

通过使用堆对象引用，如果我们想要对应的 SCP 对象引用，我们应该使用 intern() 方法。

示例：

class InternDemo
{
public static void main(String[] args)
{
String s1=new String("smith");
String s2=s1.intern();
String s3="smith";
System.out.println(s2==s3);//true
}
}

实习生流程图