jvm中string的底层分析

一、String对象一旦被创建就是固定不变的了，对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象”。因为Sring源码是被final修饰的。

 

 

二、字符串常量池

字符串常量池位于方法区，常量池分为两种，一种是静态常量池，一种是运行时常量池

 

      我们知道字符串的分配和其他对象分配一样，是需要消耗高昂的时间和空间的，而且字符串我们使用的非常多。JVM为了提高性能和减少内存的开销，在实例化字符串的时候进行了一些优化：使用字符串常量池。每当我们创建字符串常量时，JVM会首先检查字符串常量池，如果该字符串已经存在常量池中，那么就直接返回常量池中的实例引用。如果字符串不存在常量池中，就会实例化该字符串并且将其放到常量池中。由于String字符串的不可变性我们可以十分肯定常量池中一定不存在两个相同的字符串（这点对理解上面至关重要）。

 

Java中的常量池，实际上分为两种形态：静态常量池和运行时常量池。

所谓静态常量池，即*.class文件中的常量池，class文件中的常量池不仅仅包含字符串(数字)字面量，还包含类、方法的信息，占用class文件绝大部分空间。

而运行时常量池，则是jvm虚拟机在完成类装载操作后，将class文件中的常量池载入到内存中，并保存在方法区中，我们常说的常量池，就是指方法区中的运行时常量池。

 

来看下面的程序：

 

String a = "chenssy";

String b = "chenssy";

a、b和字面上的chenssy都是指向JVM字符串常量池中的"chenssy"对象，他们指向同一个对象。

 

String c = new String("chenssy");

new关键字一定会产生一个对象chenssy（注意这个chenssy和上面的chenssy不同），同时这个对象是存储在堆中。所以上面应该产生了两个对象：保存在栈中的c和保存堆中chenssy。但是在Java中根本就不存在两个完全一模一样的字符串对象。故堆中的chenssy应该是引用字符串常量池中chenssy。所以c、chenssy、池chenssy的关系应该是：c--->chenssy--->池chenssy。整个关系如下：

 

 

 

总结：虽然a、b、c、chenssy是不同的对象，但是从String的内部结构我们是可以理解上面的。String c = new String("chenssy");虽然c的内容是创建在堆中，但是他的内部value还是指向JVM常量池的chenssy的value，它构造chenssy时所用的参数依然是chenssy字符串常量。

 

例子1：

 

 

 

/**

* 采用字面值的方式赋值

*/

public void test1(){

    String str1="aaa";

    String str2="aaa";

    System.out.println("===========test1============");

    System.out.println(str1==str2);//true 可以看出str1跟str2是指向同一个对象

}

 

 

执行上述代码，结果为：true。

分析：当执行String str1="aaa"时，JVM首先会去字符串池中查找是否存在"aaa"这个对象，如果不存在，则在字符串池中创建"aaa"这个对象，然后将池中"aaa"这个对象的引用地址返回给字符串常量str1，这样str1会指向池中"aaa"这个字符串对象；如果存在，则不创建任何对象，直接将池中"aaa"这个对象的地址返回，赋给字符串常量。当创建字符串对象str2时，字符串池中已经存在"aaa"这个对象，直接把对象"aaa"的引用地址返回给str2，这样str2指向了池中"aaa"这个对象，也就是说str1和str2指向了同一个对象，因此语句System.out.println(str1 == str2)输出：true。

 

例子2：

 

 

 

/**

* 采用new关键字新建一个字符串对象

*/

public void test2(){

    String str3=new String("aaa");

    String str4=new String("aaa");

    System.out.println("===========test2============");

    System.out.println(str3==str4);//false 可以看出用new的方式是生成不同的对象

}

 

 

 执行上述代码，结果为：false。

 

分析： 采用new关键字新建一个字符串对象时，JVM首先在字符串池中查找有没有"aaa"这个字符串对象，如果有，则不在池中再去创建"aaa"这个对象了，直接在堆中创建一个"aaa"字符串对象，然后将堆中的这个"aaa"对象的地址返回赋给引用str3，这样，str3就指向了堆中创建的这个"aaa"字符串对象；如果没有，则首先在字符串池中创建一个"aaa"字符串对象，然后再在堆中创建一个"aaa"字符串对象，然后将堆中这个"aaa"字符串对象的地址返回赋给str3引用，这样，str3指向了堆中创建的这个"aaa"字符串对象。当执行String str4=new String("aaa")时， 因为采用new关键字创建对象时，每次new出来的都是一个新的对象，也即是说引用str3和str4指向的是两个不同的对象，因此语句System.out.println(str3 == str4)输出：false。

 

例子3：

 

 

 

/**

* 编译期确定

*/

public void test3(){

    String s0="helloworld";

    String s1="helloworld";

    String s2="hello"+"world";

    System.out.println("===========test3============");

    System.out.println(s0==s1); //true 可以看出s0跟s1是指向同一个对象

    System.out.println(s0==s2); //true 可以看出s0跟s2是指向同一个对象

}

 

 

执行上述代码，结果为：true、true。

 

分析：因为例子中的s0和s1中的"helloworld”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而"hello”和"world”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中"helloworld”的一个引用。所以我们得出s0==s1==s2。

 

编译后的字节码文件格式主要分为两部分：常量池和方法字节码。常量池记录的是代码出现过的所有token(类名，成员变量名等等)以及符号引用（方法引用，成员变量引用等等）；方法字节码放的是类中各个方法的字节码。这一阶段不涉及对象的创建，内存地址的分配。

 

例子4：

 

/**

* 编译期无法确定

*/

public void test4(){

    String s0="helloworld";

    String s1=new String("helloworld");

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

    System.out.println("===========test4============");

    System.out.println( s0==s1 ); //false  

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

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

}

执行上述代码，结果为：false、false、false。

 

分析：用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。创建对象是运行期发生的事，也就是代码执行，分配内存的过程

 

s0还是常量池中"helloworld”的引用，s1因为无法在编译期确定，所以是运行时创建的新对象"helloworld”的引用，s2因为有后半部分new String(”world”)所以也无法在编译期确定，所以也是一个新创建对象"helloworld”的引用。也就是说s2在栈中放有句柄，堆中有内存分配，但是而常量池中只有一种字符串，就是helloword.

 

这里加点额外的说明，下面的三点，很重要，可以查看详细说明

1.俩个或多个字面量直接相加，是在编译期间进行的，只会将结果存放在字符串常量池。类似如"aaa"+“bbb”,常量池中只会存相加的结果aaabbb，不会存aaa或者bbb

 

2.一个字符串变量和一字面量相加时，常量池中会保存字面量，而不会保存生成的字符串对象。新的对象是被存在了堆中。为什么和第一点里的情况不一样，这里的字面量会被保存在常量池中？我的理解是因为第一点字符串相加的结果在编译期就可以确定，运行期间是不需要用到相加时的字面量的，所以不需要保存。而第二种情况，结果字符串因为有变量的存在，所以编译期不可知，需要在运行时计算生成，需要运行时用到字面量，所以常量池会保存它。同样，String s = new String("aaa")； 常量池也会保存“aaa”,因为运行期生成对象会用到这个“aaa”。例如String s2="hello" + new String("world"); 常量池中会保存“helloword”.而不会存hello.

 

3.两个字符串变量相加时，与第二点类似，也是生成的新对象存储在堆上。这一点的例子下面说明

 

 

 

例子5：

 

/**

* 继续-编译期无法确定

*/

public void test5(){

    String str1="abc";   

    String str2="def";   

    String str3=str1+str2;

    System.out.println("===========test5============");

    System.out.println(str3=="abcdef"); //false

}

 

 

执行上述代码，结果为：false。

 

分析：因为str3指向堆中的"abcdef"对象，而"abcdef"是字符串池中的对象，所以结果为false。JVM对String str="abc"对象放在常量池中是在编译时做的，而String str3=str1+str2是在运行时刻才能知道的。new对象也是在运行时才做的。而这段代码总共创建了5个对象，字符串池中两个、堆中三个。+运算符会在堆中建立来两个String对象，这两个对象的值分别是"abc"和"def"，也就是说从字符串池中复制这两个值，然后在堆中创建两个对象，然后再建立对象str3,然后将"abcdef"的堆地址赋给str3。

 

这个例子运用上面解释3完美解决， String str3=str1+str2;最后只会生成一个对象存在堆，而不会再常量池中出现。

 

例子6：

 

/**

* 编译期优化

*/

public void test6(){

    String s0 = "a1";

    String s1 = "a" + 1;

    System.out.println("===========test6============");

    System.out.println((s0 == s1)); //result = true  

    String s2 = "atrue";

    String s3= "a" + "true";

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

    String s4 = "a3.4";

    String s5 = "a" + 3.4;

    System.out.println((s4 == s5)); //result = true

}

 

 

执行上述代码，结果为：true、true、true。

 

分析：在程序编译期，JVM就将常量字符串的"+"连接优化为连接后的值，拿"a" + 1来说，经编译器优化后在class中就已经是a1。在编译期其字符串常量的值就确定下来，故上面程序最终的结果都为true。

 

这个例子参照说明里面的第二条，完美解释，这里的数字就当做是字符串。

 

例子7：

 

/**

* 编译期无法确定

*/

public void test7(){

    String s0 = "ab";

    String s1 = "b";

    String s2 = "a" + s1;

    System.out.println("===========test7============");

    System.out.println((s0 == s2)); //result = false

}

执行上述代码，结果为：false。

 

分析：JVM对于字符串引用，由于在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的，即"a" + s1无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给s2。所以上面程序的结果也就为false。

 

这个例子参照说明里面的第二条，完美解释，因为常量值中只有“ab”,"b","a"，String s2 = "a" + s1; 常量池中只会存“a”,最终结果不会存到常量池中。

 

例子8：

 

/**

* 比较字符串常量的“+”和字符串引用的“+”的区别

*/

public void test8(){

    String test="javalanguagespecification";

    String str="java";

    String str1="language";

    String str2="specification";

    System.out.println("===========test8============");

    System.out.println(test == "java" + "language" + "specification");

    System.out.println(test == str + str1 + str2);

}

 

 

执行上述代码，结果为：true、false。

 

分析：为什么出现上面的结果呢？这是因为，字符串字面量拼接操作是在Java编译器编译期间就执行了，也就是说编译器编译时，直接把"java"、"language"和"specification"这三个字面量进行"+"操作得到一个"javalanguagespecification" 常量，并且直接将这个常量放入字符串池中，这样做实际上是一种优化，将3个字面量合成一个，避免了创建多余的字符串对象。而字符串引用的"+"运算是在Java运行期间执行的，即str + str2 + str3在程序执行期间才会进行计算，它会在堆内存中重新创建一个拼接后的字符串对象。总结来说就是：字面量"+"拼接是在编译期间进行的，拼接后的字符串存放在字符串池中；而字符串引用的"+"拼接运算实在运行时进行的，新创建的字符串存放在堆中

 

这个例子参照说明里面的第一条和第三条 完美解释

 

例子9：

 

 

 

/**

* 编译期确定

*/

public void test9(){

    String s0 = "ab";

    final String s1 = "b";

    String s2 = "a" + s1;  

    System.out.println("===========test9============");

    System.out.println((s0 == s2)); //result = true

}

执行上述代码，结果为：true。

 

分析：和例子7中唯一不同的是s1字符串加了final修饰，对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。所以此时的"a" + s1和"a" + "b"效果是一样的。故上面程序的结果为true。

 

这个有点特殊，因为有final的修饰

 

例子10：

 

/**

* 编译期无法确定

*/

public void test10(){

    String s0 = "ab";

    final String s1 = getS1();

    String s2 = "a" + s1;

    System.out.println("===========test10============");

    System.out.println((s0 == s2)); //result = false

    

}

 

private static String getS1() {  

    return "b";   

}

执行上述代码，结果为：false。

 

分析：这里面虽然将s1用final修饰了，但是由于其赋值是通过方法调用返回的，那么它的值只能在运行期间确定，因此s0和s2指向的不是同一个对象，故上面程序的结果为false。