JVM面试宝典-字符串常量池

字符串常量池

字符串常量池的设计思想

1. 字符串的分配，和其他的对象分配一样，耗费高昂的时间与空间代价，作为最基础的数据类型，大量频繁的创建 字符串，极大程度地影响程序的性能

2. JVM为了提高性能和减少内存开销，在实例化字符串常量的时候进行了一些优化 ，为字符串开辟一个字符串常量池，类似于缓存区 ，创建字符串常量时，首先查询字符串常量池是否存在该字符串 ，存在该字符串，返回引用实例，不存在，实例化该字符串并放入池中

三种字符串操作(Jdk1.7 及以上版本)

直接赋值字符串

1 String s = "pamgxie"; // s指向常量池中的引用

这种方式创建的字符串对象，只会在常量池中。

因为有" pamgxie "这个字面量，创建对象s的时候，JVM会先去常量池中通过 equals(key) 方法，判断是否有相同的对象

如果有，则直接返回该对象在常量池中的引用；

如果没有，则会在常量池中创建一个新对象，再返回引用。

new String();
1 String s1 = new String("pangxie"); // s1指向内存中的对象引用

这种方式会保证字符串常量池和堆中都有这个对象，没有就创建，最后返回堆内存中的对象引用。

步骤大致如下：

因为有"pangxie"这个字面量，所以会先检查字符串常量池中是否存在字符串"pangxie"

不存在，先在字符串常量池里创建一个字符串对象；再去内存中创建一个字符串对象"pangxie"；

存在的话，就直接去堆内存中创建一个字符串对象"pangxie"；

最后，将内存中的引用返回。

intern方法
1 String s1 = new String("pangxie");
2 String s2 = s1.intern();
3
4 System.out.println(s1 == s2); //false

String中的intern方法是一个 native 的方法，当调用 intern方法时，如果池已经包含一个等于此String对象的字符串

（用equals(oject)方法确定），则返回池中的字符串。 否则，将intern返回的引用指向当前字符串 s1 ( jdk1.6版本需要将

s1 复制到字符串常量池里 ) 。

字符串常量池位置

Jdk1.6及之前： 有永久代, 运行时常量池在永久代，运行时常量池包含字符串常量池

Jdk1.7：有永久代，但已经逐步“去永久代”，字符串常量池从永久代里的运行时常量池分离到堆里

Jdk1.8及之后： 无永久代，运行时常量池在元空间，字符串常量池里依然在堆里

用一个程序证明下字符串常量池在哪里：

/**
2 * jdk6：‐Xms6M ‐Xmx6M ‐XX:PermSize=6M ‐XX:MaxPermSize=6M
3 * jdk8：‐Xms6M ‐Xmx6M ‐XX:MetaspaceSize=6M ‐XX:MaxMetaspaceSize=6M
4 */
5 public class RuntimeConstantPoolOOM{
6 public static void main(String[] args) {
7 ArrayList<String> list = new ArrayList<String>();
8 for (int i = 0; i < 10000000; i++) {
9 String str = String.valueOf(i).intern();
10 list.add(str);
11 }
12 }
13 }
14
15 运行结果：
16 jdk7及以上：Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
17 jdk6：Exception in thread "main" java.lang.OutOfMemoryError: PermGen space

字符串常量池设计原理

字符串常量池底层是hotspot的C++实现的，底层类似一个 HashTable， 保存的本质上是字符串对象的引用。

看一道比较常见的面试题，下面的代码创建了多少个 String 对象？

 String s1 = new String("he") + new String("llo");
2 String s2 = s1.intern();
3
4 System.out.println(s1 == s2);
5 // 在 JDK 1.6 下输出是 false，创建了 6 个对象
6 // 在 JDK 1.7 及以上的版本输出是 true，创建了 5 个对象
7 // 当然我们这里没有考虑GC，但这些对象确实存在或存在过
8

为什么输出会有这些变化呢？主要还是字符串池从永久代中脱离、移入堆区的原因， intern() 方法也相应发生了变

化：

1、在 JDK 1.6 中，调用 intern() 首先会在字符串池中寻找 equal() 相等的字符串，假如字符串存在就返回该字符串在字

符串池中的引用；假如字符串不存在，虚拟机会重新在永久代上创建一个实例，将 StringTable 的一个表项指向这个新

创建的实例。

2、在 JDK 1.7 (及以上版本)中，由于字符串池不在永久代了，intern() 做了一些修改，更方便地利用堆中的对象。字符

串存在时和 JDK 1.6一样，但是字符串不存在时不再需要重新创建实例，可以直接指向堆上的实例。

由上面两个图，也不难理解为什么 JDK 1.6 字符串池溢出会抛出 OutOfMemoryError: PermGen space ，而在

JDK 1.7 及以上版本抛出 OutOfMemoryError: Java heap space 。

String常量池问题的几个例子

示例1：

 String s0="pangxie";
2 String s1="pangxie";
3 String s2="pang" + "xie";
4 System.out.println( s0==s1 ); //true
5 System.out.println( s0==s2 ); //true
6

分析：因为例子中的 s0和s1中的”zhuge”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；

而”zhu”和”ge”也都是字符串常量，当一个字 符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所 以s2也同样在编译期就被优化为一个字符串常量"zhuge"，所以s2也是常量池中” zhuge”的一个引用。所以我们得出

s0==s1==s2；

示例2：

1 String s0="pangxie";
2 String s1=new String("pangxie");
3 String s2="pang" + new String("xie");
4 System.out.println( s0==s1 ); // false
5 System.out.println( s0==s2 )； // false
6 System.out.println( s1==s2 ); // false

分析：用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池

中，它们有自己的地址空间。

s0还是常量池 中"pangxie”的引用，s1因为无法在编译期确定，所以是运行时创建的新对象”pangxie”的引用，s2因为有

后半部分 new String(”xie”)所以也无法在编译期确定，所以也是一个新创建对象”pangxie”的引用;明白了这些也就知

道为何得出此结果了。

示例3：

 String a = "a1";
2 String b = "a" + 1;
3 System.out.println(a == b); // true
4
5 String a = "atrue";
6 String b = "a" + "true";
7 System.out.println(a == b); // true
8
9 String a = "a3.4";
10 String b = "a" + 3.4;
11 System.out.println(a == b); // true

分析：JVM对于字符串常量的"+"号连接，将在程序编译期，JVM就将常量字符串的"+"连接优化为连接后的值，拿"a" +

1来说，经编译器优化后在class中就已经是a1。在编译期其字符串常量的值就确定下来，故上面程序最终的结果都为

true。

示例4：

 String a = "ab";
2 String bb = "b";
3 String b = "a" + bb;
4
5 System.out.println(a == b); // false
6

分析：JVM对于字符串引用，由于在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的，

即"a" + bb无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给b。所以上面程序的结果也就为

false。

示例5：

 String a = "ab";
2 final String bb = "b";
3 String b = "a" + bb;
4
5 System.out.println(a == b); // true

分析：和示例4中唯一不同的是bb字符串加了final修饰，对于final修饰的变量，它在编译时被解析为常量值的一个本地拷

贝存储到自己的常量池中或嵌入到它的字节码流中。所以此时的"a" + bb和"a" + "b"效果是一样的。故上面程序的结果 为true。

示例6：

1 String a = "ab";
2 final String bb = getBB();
3 String b = "a" + bb;
4
5 System.out.println(a == b); // false
6
7 private static String getBB()
8 {
9 return "b";
10 }
11

分析：JVM对于字符串引用bb，它的值在编译期无法确定，只有在程序运行期调用方法后，将方法的返回值和"a"来动态

连接并分配地址为b，故上面 程序的结果为false。

关于String是不可变的

通过上面例子可以得出得知：

 String s = "a" + "b" + "c"; //就等价于String s = "abc";
2 String a = "a";
3 String b = "b";
4 String c = "c";
5 String s1 = a + b + c;

s1 这个就不一样了，可以通过观察其 JVM指令码 发现s1的"+"操作会变成如下操作：

1 StringBuilder temp = new StringBuilder();
2 temp.append(a).append(b).append(c);
3 String s = temp.toString();

最后再看一个例子 ：

1 //字符串常量池："计算机"和"技术" 堆内存：str1引用的对象"计算机技术"
2 //堆内存中还有个StringBuilder的对象，但是会被gc回收，StringBuilder的toString方法会new String()，这个String才是真正返回的对
象引用
3 String str2 = new StringBuilder("计算机").append("技术").toString(); //没有出现"计算机技术"字面量，所以不会在常量池里生
成"计算机技术"对象
4 System.out.println(str2 == str2.intern()); //true
5 //"计算机技术" 在池中没有，但是在heap中存在，则intern时，会直接返回该heap中的引用
6
7 //字符串常量池："ja"和"va" 堆内存：str1引用的对象"java"
8 //堆内存中还有个StringBuilder的对象，但是会被gc回收，StringBuilder的toString方法会new String()，这个String才是真正返回的对
象引用
9 String str1 = new StringBuilder("ja").append("va").toString(); //没有出现"java"字面量，所以不会在常量池里生成"java"对象
10 System.out.println(str1 == str1.intern()); //false
11 //java是关键字，在JVM初始化的相关类里肯定早就放进字符串常量池了
12
13 String s1=new String("test");
14 System.out.println(s1==s1.intern()); //false
15 //"test"作为字面量，放入了池中，而new时s1指向的是heap中新生成的string对象，s1.intern()指向的是"test"字面量之前在池中生成的
字符串对象
16
17 String s2=new StringBuilder("abc").toString();
18 System.out.println(s2==s2.intern()); //false
19 //同上
20