深入理解Java String.intern()

大家可能都知道String.intern()的作用，调用它时，如果常量池中存在当前字符串, 就会直接返回当前字符串. 如果常量池中没有此字符串, 会将此字符串放入常量池中后, 再返回。
但是一些稍复杂的例子，可能就说不清它的运行结果，而且这结果跟jdk版本有关。本篇通过理论和例子让你对String.intern()的有更深入的理解，以及其中的原理。这不仅仅是笔试面试中常考得点，也是对技术深入探究的态度。

1. Java 各版本中String.intern()

1.1 常量池

Class文件中除了有关的版本、字段、方法、接口等描述信息外，还有一项信息是常量池，用于存放编译期生成的各种字面量和符号引用。其中字符串池（又名字符串规范化）是一个用一个共享的String替换几个具有相同值但不同身份的对象。你可以通过Map<String, String>来自己实现此目标（根据要求可能有软或弱引用），或者可以使用String.intern()由JDK提供的方法。

1.2 Java 6中的String.intern()

Java 6以及6之前中常量池存放在方法区（Perm 区）中，过多的使用intern()会直接产生java.lang.OutOfMemoryError: PermGen space错误的。因为方法区具有固定大小，不能在运行时扩展。虽然可以使用-XX:MaxPermSize=N选项进行设置，根据平台的不同，默认的PermGen大小在32M到96M之间变化。你可以增加它的大小，但它的大小仍然是固定的，这种限制使得不能不受控制的使用String.intern()。这就是Java 6时代的字符串池主要在手动管理的Map中实现的原因。

1.3 Java 7中的String.intern()

Oracle对Java 7中的常量池做了一个非常重要的改变 — 常量池被重新定位到堆中。这意味着你不再受限于单独的固定大小内存区域。所有字符串现在都位于堆中，与大多数其他普通对象一样，这使你可以在调整应用程序时仅管理堆大小。从技术上讲，这仅仅是一个使用String.intern()的理由。但还有其他原因。

常量池中的GC，如果常量不再被引用，那么JVM是可以回收它们来节省内存，因此常量池放在堆区可以更方便和堆区的其他对象一起被JVM进行垃圾收集管理。

2. String的创建及拼接

2.1 String的创建

字符串不属于基本类型，但是可以像基本类型一样，直接通过字面量赋值，当然也可以通过new来生成一个字符串对象。不过通过字面量赋值的方式和new的方式生成字符串有本质的区别：

通过字面量赋值创建字符串时，会先在常量池中查找是否已经存在相同的字符串，倘若已经存在，栈中的引用直接指向该字符串；倘若不存在，则在常量池中生成一个字符串，再将栈中的引用指向该字符串。而通过new的方式创建字符串时，就直接在堆中生成一个字符串的对象，栈中的引用指向该对象。

2.2 String的拼接

String s = "hello "+"world";//等价于直接赋值"hello world"

直接多个字符串字面量值“+”操作，编译阶段直接会合成为一个字符串。

String s1="world";
String s = "hello "+s1;

通过反编译可知以上代码相当于

String s1="world";
StringBuilder sb=new StringBuilder("hello");
sb.append(s1);
String s = sb.toString();

实际上是先创建StringBuilder，然后使用append()拼接，最后toString()赋值给s

final String s1="world";
String s = "hello "+s1;

将s1用final修饰，则拼接也是在编译时完成，编译时会先把用常量值替换s1，再就是和第一种情况相同了

String s=new String("hello ") + new String("world");

这种也是用StringBuilder拼接

3. String.intern()例子详解

例子1

public class StringTest {
    public static void main(String[] args) {
        String str1 = "string";
        String str2 = new String("string");
        String str3 = str2.intern();
 
        System.out.println(str1==str2);
        System.out.println(str1==str3);
    }
}

运行结果：
false
ture

第一个判断，因为str1指向的是常量池中的字符串常量，str2是在堆中生成的对象，所以str1==str2返回false。
第二个判断，str2调用intern()，会先在常量池中找是否有"string"字符串，池中已经有了（创建str1时添加的），所以直接返回该字符串的引用，str1和str3引用的是同一个，因此为true。

例子2

public class StringTest01 {
    public static void main(String[] args) {
        String baseStr = "baseStr";
        final String baseFinalStr = "baseStr";
 
        String str1 = "baseStr01";
        String str2 = "baseStr"+"01";
        String str3 = baseStr + "01";
        String str4 = baseFinalStr+"01";
        String str5 = new String("baseStr01").intern();
 
        System.out.println(str1 == str2);
        System.out.println(str1 == str3);
        System.out.println(str1 == str4);
        System.out.println(str1 == str5);
    }
}

按顺序依次讲解：

1. 上面字符串拼接说了，str2也相当于直接用"baseStr01"赋值，str1==str2 肯定会返回true，因为str1和str2都指向常量池中的同一引用地址。
2. str3由非常量baseStr 拼接，实际上是stringBuilder.append()生成的结果，所以与str1不相等，结果返回false。
3. str4由常量baseFinalStr 拼接，在编译时就进行了替换，等同于字面量赋值，所以为true。
4. 在常量池中已经有"baseStr01"字符串，str5和str1都引用它，所以返回true。

例子3

public class InternTest {
    public static void main(String[] args) {
 
        String str2 = new String("str")+new String("01");
        str2.intern();
        String str1 = "str01";
        System.out.println(str2==str1);
    }
}

在java 1.6运行结果：false
在java 1.7以及之后运行结果：true

和例子1一样，因为str2和str1分别指向堆中对象和常量池中字符串，所以返回false。
奇怪的是，为什么java 1.7后，结果为true呢，这就跟上面说的常量池被移到堆中有关了，intern()在实现上发生了比较大的改变，还是会先去查询常量池中是否有已经存在，如果存在，则返回常量池中的引用，这一点与之前没有区别，区别在于，如果在常量池找不到对应的字符串，则不会再将字符串拷贝到常量池，而只是在常量池中生成一个对原字符串的引用。
所以，str2.intern();这句话不是没任何影响的，它会在常量池中生成一个对堆中的“str01”的引用，而在进行字面量赋值的时候，常量池中已经存在，所以直接返回该引用即可，因此str1和str2都指向堆中的字符串，返回true。

对该例子稍作修改

public class InternTest01 {
    public static void main(String[] args) {
        String str1 = "str01";
        String str2 = new String("str")+new String("01");
        str2.intern();
        System.out.println(str2 == str1);
    }
}

将str1的定义放在前面，则java 1.6,1.7都返回false
因为这次str2.intern();执行时，常量池中已经有了"str01", 因此str1和str2引用不同。