Java常量池总结

Java常量池总结

    一、基本概念介绍

    什么是常量

    用final修饰的变量即为常量（成员变量、局部变量、静态变量，只要被final给修饰过的）。

    

    什么是常量池

    先说静态常量池，来看看class文件中都包含了哪些内容。

    其中前四个字节为魔数（确定一个class文件能否被JVM解析），后四个字节为存储版本号，其中前两个字节为次版本号，后两个为主版本号，最后就是静态常量池，其中又包含字面量，和符号引用，字面量指的就是一些字符串和声明为final类型的常量，符号引用指的是字符串在常量池的引用，包括类和接口的全限定名（如：com/test/Test），方法以及属性的名称和描述符。

    以上就是class文件的内容，运行时常量池为方法区的一部分，上述的class文件中除了有class的类信息，方法字段信息，超类以及接口信息，还有静态常量池，在方法区中他会被加载到一块叫做运行时常量池的地方。

    

    二、主角运行时常量池    

    运行时常量池用于存放class文件中的常量池内容，也就是常量和方法以及字段信息，但这些都是编译期就有的内容，显然的，他的作用不仅于此。

    并非只有编译期class文件中的常量池的内容才能入住运行时常量池，在运行时，同样也可以通过String类的intern方法，可以显式地将新的值放进常量池。

    运行时常量池的好处：

    1、节省内存，如字符串，可以无需频繁地新建内存或者销毁内存，直接在常量池共享一个字符串；

    2、节省操作时间，通过==比较字符串是否相同效率显然是优于equals方法的，如果是常量池中同一个内容的引用，就无需进行equals比较了。

    三、运行时常量池的作用

    Java共有八种基础数据类型，都有各自的封装类，基本上都有对常量池的利用。

    其中除了Float和Double，其他的六种，byte，short，int，long，boolean，char大多对常量池有利用。

    在-128到127这个区间的数，会先使用常量池中的缓存内容，大于这个区间则需要新建一个对象，源码如下：

//Integer 缓存代码 ：
public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

    再拿Integer做个例子：

  Integer i1 = 40;
  Integer i2 = 40;
  System.out.println(i1==i2);//输出TRUE

    由于40<127，所以两者都是指向了常量池中的缓存，故，输出true。

    注：如果显式地去new一个Integer对象，就会直接在堆中新建一个对象了。

    以下为更为丰富的一个例子：

  Integer i1 = 40;
  Integer i2 = 40;
  Integer i3 = 0;
  Integer i4 = new Integer(40);
  Integer i5 = new Integer(40);
  Integer i6 = new Integer(0);
  
  System.out.println("i1=i2   " + (i1 == i2));
  System.out.println("i1=i2+i3   " + (i1 == i2 + i3));
  System.out.println("i1=i4   " + (i1 == i4));
  System.out.println("i4=i5   " + (i4 == i5));
  System.out.println("i4=i5+i6   " + (i4 == i5 + i6));   
  System.out.println("40=i5+i6   " + (40 == i5 + i6));

    结果：

i1=i2   true
i1=i2+i3   true
i1=i4   false
i4=i5   false
i4=i5+i6   true
40=i5+i6   true

    总结：只要使用+或者显式地写一个等号赋值，默认的，都会去常量池中找内容。

    四、String类和常量池的关系

    String有两种创建方式，一种是直接等号赋值，一种是new String("***")。

    两者还是有本质上的区别的。

    第一种是在常量池中创建对象，一种是在堆中创建对象。

    使用+也可以生成String对象，如果加号中有String对象的引用而不是引号文本，则生成的String对象不会被加入常量池，如果加号中全部是引号文本，生成的对象会被加入常量池。

    也有特例：

    1、特例1：

public static final String A = "ab"; // 常量A
public static final String B = "cd"; // 常量B
public static void main(String[] args) {
     String s = A + B;  // 将两个常量用+连接对s进行初始化 
     String t = "abcd";   
    if (s == t) {   
         System.out.println("s等于t，它们是同一个对象");   
     } else {   
         System.out.println("s不等于t，它们不是同一个对象");   
     }   
 } 
s等于t，它们是同一个对象

    由于在编译期A和B就已经固定值了，s=A+B，效果等同于s="ab"+"cd"。

    2、特例2：

public static final String A; // 常量A
public static final String B;    // 常量B
static {   
     A = "ab";   
     B = "cd";   
 }   
 public static void main(String[] args) {   
    // 将两个常量用+连接对s进行初始化   
     String s = A + B;   
     String t = "abcd";   
    if (s == t) {   
         System.out.println("s等于t，它们是同一个对象");   
     } else {   
         System.out.println("s不等于t，它们不是同一个对象");   
     }   
 } 
s不等于t，它们不是同一个对象

    由于A和B的值，并不是在编译期就固定。

    说说创建了几个对象的问题：

    String s1 = new String("xyz"); **创建了几个对象？ **
    考虑类加载阶段和实际执行时。
    （1）类加载对一个类只会进行一次。"xyz"在类加载时就已经创建并驻留了（如果该类被加载之前已经有"xyz"字符串被驻留过则不需要重复创建用于驻留的"xyz"实例）。驻留的字符串是放在全局共享的字符串常量池中的。
    （2）在这段代码后续被运行的时候，"xyz"字面量对应的String实例已经固定了，不会再被重复创建。所以这段代码将常量池中的对象复制一份放到heap中，并且把heap中的这个对象的引用交给s1 持有。
    这条语句创建了2个对象

    Intern方法和更加丰富的String例子

    运行期可以通过intern方法将String对象放入运行时常量池中，看以下的几个例子：

public class Test {
 public static void main(String[] args) {   
      String hello = "Hello", lo = "lo";
      System.out.println((hello == "Hello") + " ");
      System.out.println((Other.hello == hello) + " ");
      System.out.println((other.Other.hello == hello) + " ");
      System.out.println((hello == ("Hel"+"lo")) + " ");
      System.out.println((hello == ("Hel"+lo)) + " ");
      System.out.println(hello == ("Hel"+lo).intern());
 }   
}
class Other { static String hello = "Hello"; }
package other;
public class Other { public static String hello = "Hello"; }

    结果：

true true true true false true```
在同包同类下,引用自同一String对象.
在同包不同类下,引用自同一String对象.
在不同包不同类下,依然引用自同一String对象.
在编译成.class时能够识别为同一字符串的,自动优化成常量,引用自同一String对象.
在运行时创建的字符串具有独立的内存地址,所以不引用自同一String对象.

    五、不同JDK版本下的intern方法

    简言之，在JDK1.6中，当常量池中没有对象，intern方法会直接在常量池创建对象，并返回常量池的引用。

    而在JDK1.7以后，intern如果在常量池中发现了字符串，还是和JDK1.6一样处理，不同的是，当常量池中没有字符串的时候，就不会再去把堆中的字符串拷贝到常量池中了，而是将堆的引用拷贝到常量池。

    注：JDK1.6以前的常量池在方法区，而JDK1.6以后的常量池在堆上。

    可以看这个链接：传送门