深入解析String和String#intern

深入解析String和String#intern

String(字符串) 类型

String类型是一种引用类型，有两种创建方法：

• 通过字面量赋值创建字符串（String s = "1"），直接使用双引号声明出来的String对象会直接存储在常量池中。
• 通过 new String() 创建字符串对象，对象存储在堆上。

运行代码：

String s1 = "1";
String s2 = "1";
System.out.println(s1 == s2);

String s3 = new String("1");
String s4 = new String("1");
System.out.println(s3 == s4);

发现结果为：
true
false

产生该结果的原因：

• 通过字面量赋值创建字符串时，当字符串常量池中没有该字符串则创建字符串存储在常量池中，而存在该字符串时则直接引用常量池中字符串，所以引用地址是相同的，结果就为true。
• 通过 new String() 创建字符串对象，每次调用都会创建新的字符串对象在堆上，所以引用地址是不相同的，结果就为false。

字符串的“+”操作：

情况一：

// 在字符串常量池中产生“11”字符串
String s = "1"+"1";

这段代码的字节码指令：
0 ldc #2 <11>
2 astore_1
3 return

情况二：

// 产生3个字符串对象，其中有2个匿名的new String("1")
String s = new String("1") + new String("1");

这段代码的字节码指令：
 0 new #2 <java/lang/StringBuilder>
 3 dup
 4 invokespecial #3 <java/lang/StringBuilder.<init> : ()V>
 7 new #4 <java/lang/String>
10 dup
11 ldc #5 <1>
13 invokespecial #6 <java/lang/String.<init> : (Ljava/lang/String;)V>
16 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
19 new #4 <java/lang/String>
22 dup
23 ldc #5 <1>
25 invokespecial #6 <java/lang/String.<init> : (Ljava/lang/String;)V>
28 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
31 invokevirtual #8 <java/lang/StringBuilder.toString : ()Ljava/lang/String;>
34 astore_1
35 return

情况三：

// 产生2个字符串对象，其中有1个匿名的new String("1")，一个是从字符串常量池中引用
String s = new String("1")+"1";

这段代码的字节码指令：
0 new #2 <java/lang/StringBuilder>
 3 dup
 4 invokespecial #3 <java/lang/StringBuilder.<init> : ()V>
 7 new #4 <java/lang/String>
10 dup
11 ldc #5 <1>
13 invokespecial #6 <java/lang/String.<init> : (Ljava/lang/String;)V>
16 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
19 ldc #5 <1>
21 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
24 invokevirtual #8 <java/lang/StringBuilder.toString : ()Ljava/lang/String;>
27 astore_1
28 return

通过三种情况的字节码指令比较发现：

• 当涉及字符串常量的"+"操作，会产生StringBuilder用于字符串的拼接，创建新的字符串对象在堆上。
• 字面量之间的"+"操作，创建的字符串存储在字符串常量池中，并不会在堆上创建对象。

注意：根据String源码可以发现String中的 private final char value[] 是引用字符串常量池中的字符串。

String#intern（String.intern()）

Java代码

    /**
     * Returns a canonical representation for the string object.
     * <p>
     * A pool of strings, initially empty, is maintained privately by the
     * class {@code String}.
     * <p>
     * When the intern method is invoked, if the pool already contains a
     * string equal to this {@code String} object as determined by
     * the {@link #equals(Object)} method, then the string from the pool is
     * returned. Otherwise, this {@code String} object is added to the
     * pool and a reference to this {@code String} object is returned.
     * <p>
     * It follows that for any two strings {@code s} and {@code t},
     * {@code s.intern() == t.intern()} is {@code true}
     * if and only if {@code s.equals(t)} is {@code true}.
     * <p>
     * All literal strings and string-valued constant expressions are
     * interned. String literals are defined in section 3.10.5 of the
     * <cite>The Java&trade; Language Specification</cite>.
     *
     * @return  a string that has the same contents as this string, but is
     *          guaranteed to be from a pool of unique strings.
     */
    public native String intern();

从注释就可以知道，如果常量池中存在当前字符串, 就会直接返回当前字符串. 如果常量池中没有此字符串, 会将此字符串放入常量池中后, 再返回。

注意：

String的String Pool（字符串常量池）是一个固定大小的Hashtable，默认值大小长度是1009，如果放进String Pool的String非常多，就会造成Hash冲突严重，从而导致链表会很长，而链表长了后直接会造成的影响就是当调用String.intern时性能会大幅下降（因为要一个一个找）。

在 jdk6中StringTable是固定的，就是1009的长度，所以如果常量池中的字符串过多就会导致效率下降很快。

在jdk7中，StringTable的长度可以通过一个参数指定：-XX:StringTableSize=99991

看一段代码：

String s1 = new String("1");
s1.intern();
String s2 = "1";
System.out.println(s == s2);

String s3 = new String("1") + new String("1");
s3.intern();
String s4 = "11";
System.out.println(s3 == s4);

打印结果是：

• jdk6 下false false
• jdk7 下false true

jdk6中的解释：

jdk6 字符串常量池放在方法区的永久代中，而字符串对象存储在堆中。

jdk6的图：

注：图中绿色线条代表 string 对象的内容指向。 黑色线条代表地址指向，堆中对象方便观察直接用代码表示了。

因为 jdk6中的常量池是放在方法区的永久代中的，方法区的永久代和堆区是完全分开的，使用引号声明的字符串都是会直接在字符串常量池中生成，而 new 出来的 String 对象是放在堆区中的。所以拿一个 堆区的对象地址和字符串常量池的对象地址进行比较肯定是不相同的，即使调用String.intern方法也是没有任何关系的。

jdk7及之后的解释：

jdk7及之后字符串常量池放在堆中，但永久代还被保留，jdk8开始永久代被移除，通过元空间替代，但字符串常量池还是放在堆中。

jdk7之后的图：

注：图中绿色线条代表 string 对象的内容指向。 黑色线条代表地址指向，堆中对象方便观察直接用代码表示了。

• 执行String s1 = new String("1"); 在堆中创建对象，并把字符串对象地址赋值给s1进行引用同时生成了常量池中的“1”，再执行s1.intern(); 发现字符串常量池中存在“1”，而s1.intern()并不会影响s1的引用，所以执行String s2 = "1";时，直接进行引用符串常量池中的“1”，因此s1 和s2的引用地址是不相同的，一个是堆上的对象地址，另一个是字符串常量池的字符串地址。
• 执行String s3 = new String("1") + new String("1"); 在堆中创建两个匿名的 new String("1"); 对象，因为通过StringBuilder的拼接只产生了“11”的字符串对象在堆上，并没有生成了常量池中的“11”，再执行s3.intern(); ，发现字符串常量池中不存在“1”，JDK1.6的做法是直接在常量池中生成一个 “11” 的对象。但是在JDK1.7中，常量池中不需要再存储一份对象了，可以直接存储堆中的引用。这份引用直接指向 s3 引用的对象，所以因此s1 和s2的引用地址是相同的。