java中关于String 类型数据 的存储方式
- 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章节.
- 对于Constant Pool,表的基本通用结构为:
- cp_info {
- u1 tag;
- u1 info[];
- }
- tag是一个数字,用来表示存储的常量的类型,例如8表示String类型,5表示Long类型,info[]根据
- 类型码tag的不同会发生相应变化.
- 对于String类型,表的结构为:
- CONSTANT_String_info {
- u1 tag;
- u2 string_index;
- }
- tag固定为8,string_index是字符串内容信息,类型为:
- CONSTANT_Utf8_info {
- u1 tag;
- u2 length;
- u1 bytes[length];
- }
- tag固定为1,length为字符串的长度,bytes[length]为字符串的内容.
- (以下代码在jdk6中编译)
- 为了详细理解Constant Pool的结构,我们参看一些代码:
- String s1 = "sss111";
- String s2 = "sss222";
- System.out.println(s1 + " " + s2);
- 由于"sss111"和"sss222"都是字符串常量,在编译期就已经创建好了存储在class文件中.
- 在编译后的class文件中会存在这2个常量的对应表示:
- 08 00 11 01 00 06 73 73 73 31 31 31 08 00 13 01 ; ......sss111....
- 00 06 73 73 73 32 32 32 ; ..sss222
- 根据上面说的String常量结构,我们分析一下
- 开始的08为CONSTANT_String_info结构中的tag,而11应该是它的相对引用,01为
- CONSTANT_Utf8_info的tag,06为对应字符串的长度,73 73 73 31 31 31为字符串对
- 应的编码,接着分析,会发现后面的是对应"sss222"的存储结构.
- 经过上面分析,我们知道了11和13是两个字符串的相对引用,就可以修改class文件
- 来修改打印的内容,把class文件中的
- 00 6E 00 04 00 03 00 00 00 24 12 10 4C 12 12 4D
- 改成
- 00 6E 00 04 00 03 00 00 00 24 12 10 4C 12 10 4D
- 程序就会输出sss111 sss111,而不是和原程序一样输出sss111 sss222,因为我
- 们把对"sss222"的相对引用12改成了对"sss111"的相对引用10.
- ------------分割线
- public class Test {
- public static void main(String[] args) {
- String s1 = "sss111";
- String s2 = "sss111";
- }
- }
- 在上面程序中存在2个相同的常量"sss111",对于n个值相同的String常量,在Constant Pool中
- 只会创建一个,所以在编译好的class文件中,我们只能找到一个对"sss111"的表示:
- 000000abh: 08 00 11 01 00 06 73 73 73 31 31 31 ; ......sss111
- 在程序执行的时候,Constant Pool会储存在Method Area,而不是heap中.
- 另外,对于""内容为空的字符串常量,会创建一个长度为0,内容为空的字符串放到Constant Pool中,
- 而且Constant Pool在运行期是可以动态扩展的.
- 关于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 Pool中.
- */
- 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)) + " ");
- 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中.
- 4.使用包含变量的字符串连接符如"aa" + s1创建的对象是运行期才创建的,存储在heap中.
- 6.使用"aa" + s1以及new String("aa" + s1)形式创建的对象是否加入到String Pool中我不太确定,可能是必须
- 调用intern()方法才会加入,希望高手能回答 @_@
- 还有几个经常考的面试题:
- 1.
- String s1 = new String("s1") ;
- String s2 = new String("s1") ;
- 上面创建了几个String对象?
- 答案:3个 ,编译期Constant Pool中创建1个,运行期heap中创建2个.
- 2.
- String s1 = "s1";
- String s2 = s1;
- s2 = "s2";
- s1指向的对象中的字符串是什么?
- 答案: "s1"
- //=======================================================================
- 综上:
- String str1 = "a";//constant pool
- String str2 = "b";//constant pool
- String str3 = new String("a");//heap
- System.out.println(str1 == str3);//false
- String str4 = "a"+str2;//heap
- String str5 = "a"+"b";//constant pool
- String str6 = new String("ab");//heap
- String str7 = "ab";//constant pool
- System.out.println(str4 == str5);//false
- System.out.println(str4.intern() == str5);//true
- System.out.println(str4 == str6);//false
- System.out.println(str5 == str7);//true
- String str8 = str6;//heap
- System.out.println(str6 == str8);//true
- String str9 = new String("ab");//heap
- System.out.println(str6 == str9);//false