java constantpool_Constant Pool和String Constant Pool详解

Constant Pool常量池的概念:

在讲到String的一些特殊情况时,总会提到String Pool或者Constant Pool,但是我想很多人都不太

明白Constant Pool到底是个怎么样的东西,运行的时候存储在哪里,所以在这里先说一下Constant Pool的内容.

String Pool是对应于在Constant Pool中存储String常量的区域.习惯称为String Pool,也有人称为

String Constant Pool.好像没有正式的命名??

在java编译好的class文件中,有个区域称为Constant Pool,他是一个由数组组成的表,类型

为cp_info constant_pool[],用来存储程序中使用的各种常量,包括Class/String/Integer等各

种基本Java数据类型,详情参见The Java Virtual Machine Specification 4.4章节.

关于String类的说明

1.String使用private final char value[]来实现字符串的存储,也就是说String对象创建之后,就不能

再修改此对象中存储的字符串内容,就是因为如此,才说String类型是不可变的(immutable).

2.String类有一个特殊的创建方法,就是使用""双引号来创建.例如new String("i am")实际创建了2个

String对象,一个是"i am"通过""双引号创建的,另一个是通过new创建的.只不过他们创建的时期不同,

一个是编译期,一个是运行期!

3.java对String类型重载了+操作符,可以直接使用+对两个字符串进行连接.

4.运行期调用String类的intern()方法可以向String Pool中动态添加对象.

String的创建方法一般有如下几种

1.直接使用""引号创建.

2.使用new String()创建.

3.使用new String("someString")创建以及其他的一些重载构造函数创建.

4.使用重载的字符串连接操作符+创建.

例1

/*

* "sss111"是编译期常量,编译时已经能确定它的值,在编译

* 好的class文件中它已经在String Pool中了,此语句会在

* String Pool中查找等于"sss111"的字符串(用equals(Object)方法确定),

* 如果存在就把引用返回,付值给s1.不存在就会创建一个"sss111"放在

* String Pool中,然后把引用返回,付值给s1.

*

*/

String s1 = "sss111";

//此语句同上

String s2 = "sss111";

/*

* 由于String Pool只会维护一个值相同的String对象

* 上面2句得到的引用是String Pool中同一个对象,所以

* 他们引用相等

*/

System.out.println(s1 == s2); //结果为true

例2

/*

* 在java中,使用new关键字会创建一个新对象,在本例中,不管在

* String Pool中是否已经有值相同的对象,都会创建了一个新的

* String对象存储在heap中,然后把引用返回赋给s1.

* 本例中使用了String的public String(String original)构造函数.

*/

String s1 = new String("sss111");

/*

* 此句会按照例1中所述在String Pool中查找

*/

String s2 = "sss111";

/*

* 由于s1是new出的新对象,存储在heap中,s2指向的对象

* 存储在String Pool中,他们肯定不是同一个对象,只是

* 存储的字符串值相同,所以返回false.

*/

System.out.println(s1 == s2); //结果为false

例3

String s1 = new String("sss111");

/*

* 当调用intern方法时，如果String Pool中已经包含一个等于此String对象

* 的字符串(用 equals(Object)方法确定),则返回池中的字符串.否则,将此

* String对象添加到池中，并返回此String对象在String Pool中的引用.

*/

s1 = s1.intern();

String s2 = "sss111";

/*

* 由于执行了s1 = s1.intern(),会使s1指向String Pool中值为"sss111"

* 的字符串对象,s2也指向了同样的对象,所以结果为true

*/

System.out.println(s1 == s2);

例4

String s1 = new String("111");

String s2 = "sss111";

/*

* 由于进行连接的2个字符串都是常量,编译期就能确定连接后的值了,

* 编译器会进行优化直接把他们表示成"sss111"存储到String Pool中,

* 由于上边的s2="sss111"已经在String Pool中加入了"sss111",

* 此句会把s3指向和s2相同的对象,所以他们引用相同.此时"sss"和"111"

* 两个常量不会再创建.

*/

String s3 = "sss" + "111";

/*

* 由于s1是个变量,在编译期不能确定它的值是多少,所以

* 会在执行的时候创建一个新的String对象存储到heap中,

* 然后赋值给s4.

*/

String s4 = "sss" + s1;

System.out.println(s2 == s3); //true

System.out.println(s2 == s4); //false

System.out.println(s2 == s4.intern()); //true

例5

这个是The Java Language Specification中3.10.5节的例子,有了上面的说明,这个应该不难理解了

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)) + " "); //lo在runtime会创建一个新的对象

System.out.println(hello == ("Hel"+lo).intern());

}

}

class Other { static String hello = "Hello"; }

package other;

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

输出结果为true true true true false true,请自行分析!

结果上面分析,总结如下:

1.单独使用""引号创建的字符串都是常量,编译期就已经确定存储到String Pool中.

2.使用new String("")创建的对象会存储到heap中,是运行期新创建的.

3.使用只包含常量的字符串连接符如"aa" + "aa"创建的也是常量,编译期就能确定,已经确定存储到String

Pool中.(编译时会直接优化成"aaaa"，如果String Pool

中没有"aaaa"，就用""号创建一个String,直接放到Pool中,比如：String t = "a"+ "b" +"c";

会优化成"abc",然后放入Pool中；又比如String s = "x"+"y"+ref;在编译时有部分的优化:"xy"，而ref + "x"

+"y"就不会有部分的优化，"+"从左到右执行，ref是变量，编译时期无法确定)

4.使用包含变量的字符串连接符如"aa" + s1创建的对象是运行期才创建的,存储在heap中.

(根据java api文档中String类所讲，会在内部使用stringbuffer及其append方法来实现连接，然后执行toString()，这样就会在运行时又创建一个新对象)

还有几个经常考的面试题:

1.

String s1 = new String("s1") ;

String s2 = new String("s1") ;

上面创建了几个String对象?

答案:3个 ,编译期Constant Pool中创建1个,运行期heap中创建2个.