[Java] JVM常量池的深入讲解

public class com.qjc.construction.Test
  minor version: 0
  major version: 51
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref      #7.#27     // java/lang/Object."<init>":()V
   #2 = Class        #28      // com/qjc/construction/Test
   #3 = Methodref      #2.#27     // com/qjc/construction/Test."<init>":()V
   #4 = Methodref      #2.#29     // com/qjc/construction/Test.test:()I
   #5 = Fieldref       #30.#31    // java/lang/System.out:Ljava/io/PrintStream;
   #6 = Methodref      #32.#33    // java/io/PrintStream.println:(Ljava/lang/Object;)V
   #7 = Class        #34      // java/lang/Object
   #8 = Utf8         <init>
   #9 = Utf8         ()V
  #10 = Utf8         Code
  #11 = Utf8         LineNumberTable
  #12 = Utf8         LocalVariableTable
  #13 = Utf8         this
  #14 = Utf8         Lcom/qjc/construction/Test;
  #15 = Utf8         test
  #16 = Utf8         ()I
  #17 = Utf8         a
  #18 = Utf8         I
  #19 = Utf8         b
  #20 = Utf8         c
  #21 = Utf8         main
  #22 = Utf8         ([Ljava/lang/String;)V
  #23 = Utf8         args
  #24 = Utf8         [Ljava/lang/String;
  #25 = Utf8         SourceFile
  #26 = Utf8         Test.java
  #27 = NameAndType    #8:#9      // "<init>":()V
  #28 = Utf8         com/qjc/construction/Test
  #29 = NameAndType    #15:#16    // test:()I
  #30 = Class        #35      // java/lang/System
  #31 = NameAndType    #36:#37    // out:Ljava/io/PrintStream;
  #32 = Class        #38      // java/io/PrintStream
  #33 = NameAndType    #39:#40    // println:(Ljava/lang/Object;)V
  #34 = Utf8         java/lang/Object
  #35 = Utf8         java/lang/System
  #36 = Utf8         out
  #37 = Utf8         Ljava/io/PrintStream;
  #38 = Utf8         java/io/PrintStream
  #39 = Utf8         println
  #40 = Utf8         (Ljava/lang/Object;)V

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

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

• 为字符串开辟一个字符串常量池，类似于缓存区
  
• 创建字符串常量时，首先查询字符串常量池是否存在该字符串
  
• 存在该字符串，返回引用实例，不存在，实例化该字符串并放入池中
  
• 三种字符串操作(Jdk1.7 及以上版本)
  
• 直接赋值字符串
  

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

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

String s1 = new String("qjc");   
String s2 = s1.intern();
System.out.println(s1 == s2);  //false

/**
 * @author qijianchun
 * @title: TestPool
 * @projectName 
 * @description: TODO JDK8:-Xms6M -Xmx6M -XX:MetaspaceSize=10M -XX:MaxMetaspaceSize=10M
 * @description: TODO JDK6:-Xms6M -Xmx6M -XX:PermSize=6M -XX:MaxPermSize=6M
 * @date 2021/4/1313:02
 */
public class TestPool {
  public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<String>();
    for (int i = 0; i < 10000000; i++) {
      String str = String.valueOf(i).intern();
      list.add(str);
    }
  }
}

运行结果：
jdk7及以上：Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
jdk6：Exception in thread "main" java.lang.OutOfMemoryError: PermGen space

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，但这些对象确实存在或存在过

String s0="qjc";
String s1="qjc";
String s2="qj" + "c";
System.out.println( s0==s1 ); //true
System.out.println( s0==s2 ); //true

String s0="qjc";
String s1=new String("qjc");
String s2="qj" + new String("c");
System.out.println( s0==s1 );// false
System.out.println( s0==s2 );// false
System.out.println( s1==s2 );// false

String a = "a1";
String b = "a" + 1;
System.out.println(a == b); // true
String a1 = "atrue";
String b1 = "a" + "true";
System.out.println(a1 == b1); // true
String a2 = "a3.4";
String b2 = "a" + 3.4;
System.out.println(a2 == b2); // true

String a = "ab";
String bb = "b";
String b = "a" + bb;
System.out.println(a == b); // false

String a = "ab";
final String bb = "b";
String b = "a" + bb;
System.out.println(a == b); // true

String a = "ab";
final String bb = getBB();
String b = "a" + bb;
System.out.println(a == b); // false
private static String getBB() 
{  
  return "b";  
 }

String  s  =  "a" + "b" + "c";  //就等价于String s = "abc";
String  a  =  "a";
String  b  =  "b";
String  c  =  "c";
String  s1  =   a  +  b  +  c;

StringBuilder temp = new StringBuilder();
temp.append(a).append(b).append(c);
String s = temp.toString();

//字符串常量池："计算机"和"技术"   堆内存：str1引用的对象"计算机技术"  
//堆内存中还有个StringBuilder的对象，但是会被gc回收，StringBuilder的toString方法会new String()，这个String才是真正返回的对象引用
String str2 = new StringBuilder("计算机").append("技术").toString();   //没有出现"计算机技术"字面量，所以不会在常量池里生成"计算机技术"对象
System.out.println(str2 == str2.intern());  //true
//"计算机技术" 在池中没有，但是在heap中存在，则intern时，会直接返回该heap中的引用

//字符串常量池："ja"和"va"   堆内存：str1引用的对象"java"  
//堆内存中还有个StringBuilder的对象，但是会被gc回收，StringBuilder的toString方法会new String()，这个String才是真正返回的对象引用
String str1 = new StringBuilder("ja").append("va").toString();  //没有出现"java"字面量，所以不会在常量池里生成"java"对象
System.out.println(str1 == str1.intern());  //false
//java是关键字，在JVM初始化的相关类里肯定早就放进字符串常量池了

String s1=new String("test");  
System.out.println(s1==s1.intern());   //false
//"test"作为字面量，放入了池中，而new时s1指向的是heap中新生成的string对象，s1.intern()指向的是"test"字面量之前在池中生成的字符串对象
String s2=new StringBuilder("abc").toString();
System.out.println(s2==s2.intern());  //false
//同上

//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