深入浅出 java 常量池

jvm 虚拟内存分布：

程序计数器是 jvm 执行程序的流水线，存放一些跳转指令。
本地方法栈是 jvm 调用操作系统方法所使用的栈。
虚拟机栈是 jvm 执行 java 代码所使用的栈。
方法区存放了一些常量、静态变量、类信息等，可以理解成 class 文件在内存中的存放位置。
虚拟机堆是 jvm 执行 java 代码所使用的堆。

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

所谓静态常量池，即 .class 文件中的常量池，class 文件中的常量池不仅仅包含字符串(数字)字面量，还包含类、方法的信息，占用 class 文件绝大部分空间。这种常量池主要用于存放两大类常量：字面量(Literal)和符号引用量(Symbolic References)，字面量相当于 Java 语言层面常量的概念，如文本字符串，声明为 final 的常量值等，符号引用则属于编译原理方面的概念，包括了如下三种类型的常量：

• 类和接口的全限定名
• 字段名称和描述符
• 方法名称和描述符

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

运行时常量池相对于 CLass 文件常量池的另外一个重要特征是具备动态性，Java 语言并不要求常量一定只有编译期才能产生，也就是并非预置入 CLass 文件中常量池的内容才能进入方法区运行时常量池，运行期间也可能将新的常量放入池中，这种特性被开发人员利用比较多的就是**String 类的 intern()**方法。

String 的 intern()方法会查找在常量池中是否存在一份 equal 相等的字符串,如果有则返回该字符串的引用,如果没有则添加自己的字符串进入常量池。

常量池的好处

常量池是为了避免频繁的创建和销毁对象而影响系统性能，其实现了对象的共享。
例如字符串常量池，在编译阶段就把所有的字符串文字放到一个常量池中。

（1）节省内存空间：常量池中所有相同的字符串常量被合并，只占用一个空间。
（2）节省运行时间：比较字符串时，==比 equals()快。对于两个引用变量，只用==判断引用是否相等，也就可以判断实际值是否相等。

接下来我们引用一些网络上流行的常量池例子，然后借以讲解。

String s1 = "Hello";
String s2 = "Hello";
String s3 = "Hel" + "lo";
String s4 = "Hel" + new String("lo");
String s5 = new String("Hello");
String s6 = s5.intern();
String s7 = "H";
String s8 = "ello";
String s9 = s7 + s8;
          
System.out.println(s1 == s2);  // true
System.out.println(s1 == s3);  // true
System.out.println(s1 == s4);  // false
System.out.println(s1 == s9);  // false
System.out.println(s4 == s5);  // false
System.out.println(s1 == s6);  // true

首先说明一点，在 java 中，直接使用==操作符，比较的是两个字符串的引用地址，并不是比较内容，比较内容请用 String.equals()。

　　s1 == s2 这个非常好理解，s1、s2 在赋值时，均使用的字符串字面量，说白话点，就是直接把字符串写死，在编译期间，这种字面量会直接放入 class 文件的常量池中，从而实现复用，载入运行时常量池后，s1、s2 指向的是同一个内存地址，所以相等。

　　s1 == s3 这个地方有个坑，s3 虽然是动态拼接出来的字符串，但是所有参与拼接的部分都是已知的字面量，在编译期间，这种拼接会被优化，编译器直接帮你拼好，因此 String s3 = "Hel" + "lo";在 class 文件中被优化成 String s3 = "Hello"，所以 s1 == s3 成立。只有使用引号包含文本的方式创建的 String 对象之间使用“+”连接产生的新对象才会被加入字符串池中。

　　s1 == s4 当然不相等，s4 虽然也是拼接出来的，但 new String("lo")这部分不是已知字面量，是一个不可预料的部分，编译器不会优化，必须等到运行时才可以确定结果，结合字符串不变定理，鬼知道 s4 被分配到哪去了，所以地址肯定不同。对于所有包含 new 方式新建对象（包括 null）的“+”连接表达式，它所产生的新对象都不会被加入字符串池中。
配上一张简图理清思路：

　　s1 == s9 也不相等，道理差不多，虽然 s7、s8 在赋值的时候使用的字符串字面量，但是拼接成 s9 的时候，s7、s8 作为两个变量，都是不可预料的，编译器毕竟是编译器，不可能当解释器用，不能在编译期被确定，所以不做优化，只能等到运行时，在堆中创建 s7、s8 拼接成的新字符串，在堆中地址不确定，不可能与方法区常量池中的 s1 地址相同。

　　s4 == s5 已经不用解释了，绝对不相等，二者都在堆中，但地址不同。

　　s1 == s6 这两个相等完全归功于 intern 方法，s5 在堆中，内容为 Hello ，intern 方法会尝试将 Hello 字符串添加到常量池中，并返回其在常量池中的地址，因为常量池中已经有了 Hello 字符串，所以 intern 方法直接返回地址；而 s1 在编译期就已经指向常量池了，因此 s1 和 s6 指向同一地址，相等。

• 特例 １

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 的值也是固定的，它在类被编译时就已经确定了。也就是说：String s=A+B; 等同于：String s="ab"+"cd";

• 特例 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 虽然被定义为常量，但是它们都没有马上被赋值。在运算出 s 的值之前，他们何时被赋值，以及被赋予什么样的值，都是个变数。因此 A 和 B 在被赋值之前，性质类似于一个变量。那么 s 就不能在编译期被确定，而只能在运行时被创建了。

至此，我们可以得出三个非常重要的结论：

**  必须要关注编译期的行为，才能更好的理解常量池。**

**  运行时常量池中的常量，基本来源于各个 class 文件中的常量池。**

**  程序运行时，除非手动向常量池中添加常量(比如调用 intern 方法)，否则 jvm 不会自动添加常量到常量池**

　　以上所讲仅涉及字符串常量池，实际上还有整型常量池、浮点型常量池(java 中基本类型的包装类的大部分都实现了常量池技术，即 Byte,Short,Integer,Long,Character,Boolean_；_两种浮点数类型的包装类 Float,Double 并没有实现常量池技术) 等等，但都大同小异，只不过数值类型的常量池不可以手动添加常量，程序启动时常量池中的常量就已经确定了，比如整型常量池中的常量范围：-128~127，（Byte,Short,Integer,Long,Character,Boolean）这 5 种包装类默认创建了数值[-128，127]的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。

　　例如在自动装箱时，把 int 变成 Integer 的时候，是有规则的，当你的 int 的值在-128-IntegerCache.high(127) 时，返回的不是一个新 new 出来的 Integer 对象，而是一个已经缓存在堆 中的 Integer 对象，（我们可以这样理解，系统已经把-128 到 127 之 间的 Integer 缓存到一个 Integer 数组中去了，如果你要把一个 int 变成一个 Integer 对象，首先去缓存中找，找到的话直接返回引用给你就 行了，不必再新 new 一个），如果不在-128-IntegerCache.high(127) 时会返回一个新 new 出来的 Integer 对象。