JVM常量池 - 技术栈

Class常量池/运行时常量池

二级制的Class文件中的常量池部分。

java 复制代码

int a = 1;
int b = 2;
int c = "abcdefg";
int d = "abcdefg";

常量池中主要存放两大类常量：字面量和符号引用。

字面量：指由字母、数字等构成的字符串或者数值常量。 字面量只可能出现在等号右边。

符号引用：主要包括了以下三类常量的引用

类和接口的全限定名：类常量池里的 Lcom/tuling/jvm/Math 是类的全限定名，是符号引用
字段的名称和描述符：a、b就是字段名，是符号引用
方法的名称和描述：main和compute是方法名称，()是一种UTF8格式的描述符，这些都是符号引用

这些常量池现在是静态信息，只有到运行时被加载到JVM内存后，这些符号才有对应的内存地址信息。这些常量池一旦被装入内存就变成运行时常量池，对应的符号引用在程序加载或运行时 会被转变为被加载到内存区域的代码的直接引用，也就是我们说的动态链接了。

例如，compute()这个符号引用在运行时就会被转变为compute()方法具体代码在内存中的地址，主要通过对象头里的类型指针去转换直接引用。

字符串常量

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

直接赋值

java 复制代码

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

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

new String()

java 复制代码

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

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

intern方法(native方法)

java 复制代码

String s1 = new String("zhuge");   
String s2 = s1.intern();

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

intern返回的是常量池的引用。

intern方法时，如果字符串常量池已经包含一个等于此String对象的字符串（用equals(oject)方法确定），则返回池中的字符串。否则，将intern返回的引用指向当前字符串 s1 (jdk1.6****版本需要将 s1 复制到字符串常量池里 )。

字符串常量池位置

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

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

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

字符串常量池的设计原理

java 复制代码

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

Jdk1.6：

Jdk1.7

区别：

在 JDK 1.6 中，调用 intern() 首先会在字符串池中寻找 equal() 相等的字符串，假如字符串存在就返回该字符串在字符串池中的引用；假如字符串不存在，JVM会重新在永久代上创建一个实例，将 StringTable 的一个表项指向这个新创建的实例.

JDK1.7中，不存在永久代了，常量池也移到了堆中，调用intern() 中，字符串不存在时不再需要重新创建实例，可以直接指向堆上的实例。

示例1：

java 复制代码

String s0="zhuge";
String s1=new String("zhuge");
String s2="zhu" + new String("ge");
System.out.println( s0==s1 );　　// false
System.out.println( s0==s2 )；　 // false， s2运行时才确定，所以s2也是运行时新创建的对象
System.out.println( s1==s2 );　　// false

示例2：

java 复制代码

  String a = "a1";
  String b = "a" + 1;
  System.out.println(a == b); // true ， JVM对于字符串常量的"+"号连接，将在程序编译期，JVM就将常量字符串的"+"连接优化为连接后的值
  
  String a = "atrue";
  String b = "a" + "true";
  System.out.println(a == b); // true 
  
  String a = "a3.4";
  String b = "a" + 3.4;
  System.out.println(a == b); // true

示例3：

java 复制代码

String a = "ab";
String bb = "b";
String b = "a" + bb; // 在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的

System.out.println(a == b); // false

示例4：

java 复制代码

String a = "ab";
final String bb = "b"; // final修饰的变量，它在编译时可以确认
String b = "a" + bb;

System.out.println(a == b); // true

示例5：

java 复制代码

String str2 = new StringBuilder("计算机").append("技术").toString();   //没有出现"计算机技术"字面量，所以不会在常量池里生成"计算机技术"对象
System.out.println(str2 == str2.intern());  //true， "计算机技术" 在池中没有，但是在heap中存在，则intern时，会直接返回该heap中的引用

八种基本类型的包装类和对象池

java中基本类型的包装类的大部分都实现了常量池技术(严格来说应该叫**对象池，**在堆上)，这些类是Byte,Short,Integer,Long,Character,Boolean, 另外两种浮点数类型的包装类则没有实现。

另外Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127时才可使用对象池，也即对象不负责创建和管理大于127的这些类的对象。因为一般这种比较小的数用到的概率相对较大。

java 复制代码

public class Test {

    public static void main(String[] args) {
        //5种整形的包装类Byte,Short,Integer,Long,Character的对象，  
        //在值小于127时可以使用对象池  
        Integer i1 = 127;  //这种调用底层实际是执行的Integer.valueOf(127)，里面用到了IntegerCache对象池
        Integer i2 = 127;
        System.out.println(i1 == i2);//输出true  

        //值大于127时，不会从对象池中取对象  
        Integer i3 = 128;
        Integer i4 = 128;
        System.out.println(i3 == i4);//输出false  
        
        //用new关键词新生成对象不会使用对象池
        Integer i5 = new Integer(127);  
        Integer i6 = new Integer(127);
        System.out.println(i5 == i6);//输出false 

        //Boolean类也实现了对象池技术  
        Boolean bool1 = true;
        Boolean bool2 = true;
        System.out.println(bool1 == bool2);//输出true  

        //浮点类型的包装类没有实现对象池技术  
        Double d1 = 1.0;
        Double d2 = 1.0;
        System.out.println(d1 == d2);//输出false  
    }
}