字符串常量池理解

在JVM中，为了减小字符串对象的重复建立，维护了一块特殊的内存空间，这块内存就被称为字符串常量池。

在JDK1.6及以前，字符串常量池存放在方法区中。到JDK1.7以后，就从方法区中移除了，而存放在堆中。如下是《深刻理解Java虚拟机》第二版原文:

对于HotSpot虚拟机，根据官方发布的路线图信息，如今也有放弃永久代并逐步改成采用Native Memory来实现方法区的规划了，在目前已经发布的JDK1.7 的HotSpot中，已经把本来放在永久代的字符串常量池移出。

咱们知道字符串常量通常有两种建立方式：

1. 使用字符串字面量定义

String s = "aa";

1. 经过new建立字符串对象

String s = new String("aa");

那这两种方式有什么区别呢？

第一种方式经过字面量定义一个字符串时，JVM会先去字符串常量池中检查是否存在“aa”这个对象。若是不存在，则在字符串常量池中建立“aa”对象，并将引用返回给s，这样s的引用就指向字符串常量池中的“aa”对象。若是存在，则不建立任何对象，直接把常量池中“aa”对象的地址返回，赋值给s。

第二种方式经过new关键字建立一个字符串时，咱们须要知道建立了几个对象，这也是面试中常常问到的。首先，会在字符串常量池中建立一个"aa"对象。而后执行new String时会在堆中建立一个“aa”的对象，而后把s的引用指向堆中的这个“aa”对象。

思考如下代码的打印结果：

public class StringTest {
    public static void main(String[] args) {
        //建立了两个对象，一份存在字符串常量池中，一份存在堆中
        String s = new String("aa");
        //检查常量池中是否存在字符串aa，此处存在则直接返回
        String s1 = s.intern();
        String s2 = "aa";

        System.out.println(s == s2);  //①
        System.out.println(s1 == s2); //②

        String s3 = new String("b") + new String("b");
        //常量池中没有bb，在jdk1.7以后会把堆中的引用放到常量池中，故引用地址相等
        String s4 = s3.intern();
        String s5 = "bb";

        System.out.println(s3 == s5 ); //③
        System.out.println(s4 == s5);  //④

    }
}

以上的①②③④四个地方应该输出true仍是false呢？别着急，先看下，代码中用到了intern方法。这个方法的做用是，在运行期间能够把新的常量放入到字符串常量池中。

看下String源码中对intern方法的解释：

字面意思就是，当调用这个方法时，会去检查字符串常量池中是否已经存在这个字符串，若是存在的话，就直接返回，若是不存在的话，就把这个字符串常量加入到字符串常量池中，而后再返回其引用。

可是，其实在JDK1.6和 JDK1.7的处理方式是有一些不一样的。

在JDK1.6中，若是字符串常量池中已经存在该字符串对象，则直接返回池中此字符串对象的引用。不然，将此字符串的对象添加到字符串常量池中，而后返回该字符串对象的引用。

在JDK1.7中，若是字符串常量池中已经存在该字符串对象，则返回池中此字符串对象的引用。不然，若是堆中已经有这个字符串对象了，则把此字符串对象的引用添加到字符串常量池中并返回该引用，若是堆中没有此字符串对象，则先在堆中建立字符串对象，再返回其引用。（这也说明，此时字符串常量池中存储的是对象的引用，而对象自己存储于堆中）

因而代码中，String s = new String("aa");建立了两个“aa”对象，一个存在字符串常量池中，一个存在堆中。

String s1 = s.intern(); 因为字符串常量池中已经存在“aa”对象，因而直接返回其引用，故s1指向字符串常量池中的对象。

String s2 = "aa"; 此时字符串常量池中已经存在“aa”对象，因此也直接返回，故 s2和 s1的地址相同。②返回true。

System.out.println(s == s2); 因为s的引用指向的是堆中的“aa”对象，s2指向的是常量池中的对象。故不相等，①返回false。

String s3 = new String("b") + new String("b"); 先说明一下，这种形式的字符串拼接，等同于使用StringBuilder的append方法把两个“b”拼接，而后调用toString方法，new出“bb”对象，所以“bb”对象是在堆中生成的。因此，这段代码最终生成了两个对象，一个是“b”对象存在于字符串常量池中，一个是 “bb”对象，存在于堆中，可是此时字符串常量池中是没有“bb”对象的。 s3指向的是堆中的“bb”对象。

String s4 = s3.intern(); 调用了intern方法以后，在JDK1.6中，因为字符串常量池中没有“bb”对象，故建立一个“bb”对象，而后返回其引用。因此 s4 这个引用指向的是字符串常量池中新建立的“bb”对象。在JDK1.7中，则把堆中“bb”对象的引用添加到字符串常量池中，故s4和s3所指向的对象是同一个，都指向堆中的“bb”对象。

String s5 = "bb"; 在JDK1.6中，指向字符串常量池中的“bb”对象的引用，在JDK1.7中指向的是堆中“bb”对象的引用。

System.out.println(s3 == s5 ); 参照以上分析便可知道，在JDK1.6中③返回false（由于s3指向的是堆中的“bb”对象，s5指向的是字符串常量池中的“bb”对象），在JDK1.7中，③返回true（由于s3和s5指向的都是堆中的“bb”对象）。

System.out.println(s4 == s5); 在JDK1.6中，s4和s5指向的都是字符串常量池中建立的“bb”对象，在JDK1.7中，s4和s5指向的都是堆中的“bb”对象。故不管JDK版本如何，④都返回true。

综上，在JDK1.6中，返回的结果为：

false
true
false
true

在JDK1.7中，返回结果为：

false
true
true
true

以上，能够在JDK1.7和JDK1.6中分别验证。注意一下，最好搞两个项目而后分别设置不一样的JDK，由于若是在一个项目中直接更改JDK版本，有可能高版本编译以后，低版本编译不经过。

原理搞懂了，咱们再思考一下如下代码的结果：

public class InternTest {
    public static void main(String[] args) {
        String str1 = "xy";
        String str2 = "z";
        String str3 = "xyz";
        String str4 = str1 + str2;
        String str5 = str4.intern();
        String str6 = "xy" + "z";

        System.out.println(str3 == str4); //⑤
        System.out.println(str3 == str5); //⑥
        System.out.println(str3 == str6); //⑦
    }
}

咱们分析一下。

str一、str2和str3都是简单的定义字符串，全部它们都是在字符串常量池中建立对象，而后引用指向字符串常量池中的对象。

String str4 = str1 + str2; 这段代码和以前的 String s3 = new String("b") + new String("b"); 原理相同，所以在堆中建立了一个“xyz”对象，而后str4指向堆中的这个对象。故⑤处返回false。（str3指向的是字符串常量池中的“xyz”对象）

String str5 = str4.intern(); 因为字符串常量池中已经存在“xyz”对象，所以不管是JDK1.6仍是JDK1.7，此处返回的都是字符串常量池中对象的引用。因此str5指向字符串常量池中的对象，故 ⑥返回true。

String str6 = "xy" + "z"; 这段代码须要说明一下，它不一样于两个字符串的引用拼接（如str1 + str2）。JVM会对其优化处理，也就是在编译阶段会把“xy”和“z”进行拼接成为“xyz”，存放在字符串常量池。所以，str6指向的是字符串常量池的对象，故⑦返回true。