本文概述:
静态常量池如何存储, 并且存储哪些信息

注: 本文不是按照理论来存储的, 本文注重于从现象得出结论

静态常量池是什么

静态常量池位于 Class 文件中, 当你对一个文件进行编译之后, 生成一个 class 文件, 里面存储了一个类的所有信息, 这个 class 字节码使得 Java 真正实现了跨平台, 一次编译, 到处运行.
Constant Pool 里面存储了一个类的所有对象"引用"和部分的基本数据类型的值 (如果你好奇, 具体如何存储的, 看上一篇文章), 这里简单说一下, 当创建一个对象引用, 在代码运行的时候, 引用指向的就是对象实例. 但是在文件中无法指向, 在 Class 文件中,对象引用指向的就是一个字符串, 这个字符串就是对象实例的全限定名, 通过这个全限定名, 在真正运行的时候就可以去寻找目标类了,这个字符串, 被称为符号引用

总而言之, 引用类型, 字面量, final 变量, 静态引用都是存储在这里的, 不过需要注意的是, 不要觉得静态常量池中存储的是真正的引用, 实际上这里的"引用", 只是一个序号
![[Pasted image 20230316224731.png]]
比如说我定义了
String s = "JVM"原理,
我存储的是 s 引用吗, 不是, 他只是一个序号 #15 是 s 引用的序号, 这个"引用"指向了 #16 序号, 而这个 #16 指的就是一个普通的字符串.

所有引用类型, 包括 Class 对象, 都是这么存储的. 具体如存储的, 可以参考上一篇博客

这里我们做一个实验, 来测试一下

/*** 
* 这里测试 Class 文件中的 ConstantPool 相关测试* 
** @author ggzx* @since 2023/3/14*/
public class ConstantPoolTest {private int int_num = 110;private char char_num = 'a';private short short_num = 120;private float float_num = 130.0f;private double double_num = 140.0;private byte byte_num = 111;private long long_num = 3333L;private long long_delay_num;private boolean boolean_flag = true;public static void main(String[] args) {String g = "ggzx";}
}

下面来看看字节码, 对于重点部分, 我会标注, 你只需要注意中文注解即可

Classfile /E:/VSCODE_FILE/Test/src/main/java/org/example/jvm/ConstantPoolTest.classLast modified 2023-3-14; size 710 bytesMD5 checksum 30896b5e6fccdb34ecc7c03e41cfbed5Compiled from "ConstantPoolTest.java"
public class org.example.jvm.ConstantPoolTestminor version: 0major version: 52flags: ACC_PUBLIC, ACC_SUPER
Constant pool:#1 = Methodref          #17.#43        // java/lang/Object."":()V#2 = Fieldref           #16.#44        // org/example/jvm/ConstantPoolTest.int_num:I  #3 = Fieldref           #16.#45        // org/example/jvm/ConstantPoolTest.char_num:C #4 = Fieldref           #16.#46        // org/example/jvm/ConstantPoolTest.short_num:S// !!!!!!!!这里是我们定义的#5 = Float              130.0f#6 = Fieldref           #16.#47        // org/example/jvm/ConstantPoolTest.float_num:F// !!!!!!!!这里是我们定义的#7 = Double             140.0d#9 = Fieldref           #16.#48        // org/example/jvm/ConstantPoolTest.double_num:D#10 = Fieldref           #16.#49        // org/example/jvm/ConstantPoolTest.byte_num:B// !!!!!!!!这里是我们定义的#11 = Long               3333l#13 = Fieldref           #16.#50        // org/example/jvm/ConstantPoolTest.long_num:J#14 = Fieldref           #16.#51        // org/example/jvm/ConstantPoolTest.boolean_flag:Z// !!!!!!!!这里是我们定义的#15 = String             #52            // ggzx#16 = Class              #53            // org/example/jvm/ConstantPoolTest#17 = Class              #54            // java/lang/Object#18 = Utf8               int_num#19 = Utf8               I#20 = Utf8               char_num#21 = Utf8               C#22 = Utf8               short_num#23 = Utf8               S#24 = Utf8               float_num#25 = Utf8               F#26 = Utf8               double_num#27 = Utf8               D#28 = Utf8               byte_num#29 = Utf8               B#30 = Utf8               long_num#31 = Utf8               J#32 = Utf8               long_delay_num#33 = Utf8               boolean_flag#34 = Utf8               Z#35 = Utf8               #36 = Utf8               ()V#37 = Utf8               Code#38 = Utf8               LineNumberTable#39 = Utf8               main#40 = Utf8               ([Ljava/lang/String;)V#41 = Utf8               SourceFile#42 = Utf8               ConstantPoolTest.java#43 = NameAndType        #35:#36        // "":()V#44 = NameAndType        #18:#19        // int_num:I#45 = NameAndType        #20:#21        // char_num:C#46 = NameAndType        #22:#23        // short_num:S#47 = NameAndType        #24:#25        // float_num:F#48 = NameAndType        #26:#27        // double_num:D#49 = NameAndType        #28:#29        // byte_num:B#50 = NameAndType        #30:#31        // long_num:J#51 = NameAndType        #33:#34        // boolean_flag:Z#52 = Utf8               ggzx#53 = Utf8               org/example/jvm/ConstantPoolTest#54 = Utf8               java/lang/Object
{public org.example.jvm.ConstantPoolTest();descriptor: ()Vflags: ACC_PUBLICCode:stack=3, locals=1, args_size=10: aload_01: invokespecial #1                  // Method java/lang/Object."":()V4: aload_05: bipush        1107: putfield      #2                  // Field int_num:I10: aload_011: bipush        9713: putfield      #3                  // Field char_num:C16: aload_017: bipush        12019: putfield      #4                  // Field short_num:S22: aload_023: ldc           #5                  // float 130.0f25: putfield      #6                  // Field float_num:F28: aload_029: ldc2_w        #7                  // double 140.0d32: putfield      #9                  // Field double_num:D35: aload_036: bipush        11138: putfield      #10                 // Field byte_num:B41: aload_042: ldc2_w        #11                 // long 3333l45: putfield      #13                 // Field long_num:J48: aload_049: iconst_150: putfield      #14                 // Field boolean_flag:Z53: returnLineNumberTable:line 13: 0line 15: 4line 16: 10line 17: 16line 18: 22line 19: 28line 20: 35line 21: 41line 23: 48public static void main(java.lang.String[]);descriptor: ([Ljava/lang/String;)Vflags: ACC_PUBLIC, ACC_STATICCode:stack=1, locals=2, args_size=10: ldc           #15                 // String ggzx2: astore_13: returnLineNumberTable:line 26: 0line 27: 3
}
SourceFile: "ConstantPoolTest.java"

总结一下哈:

1. 【final 修饰】的 8 种基本类型的值会进⼊常量池。
2. 【⾮final 类型】（包括 static 的）的 8 种基本类型的值，只有【double、float、long】的值会进⼊常量池。
3. 常量池中包含的字符串类型字⾯量（【双引号引起来的字符串值】）。

注意, 注意, 上面的其实是有问题的, 上面是某个有名的机构的出来的结果, 我做了几个实验, 第二步不完全对, 等下就讲, 说实话这里也是我误打误撞做实验的出来的

首先,这里你可能会有一个疑问, 为啥 int, char, byte, short, boolean 都没有放到基本的常量池中, 那么没有放到常量池以后如何进行赋值的呢?
来测试一下:

    public static void main(String[] args) {String g = "ggzx";int i = 32767;boolean b = true;char char_num = 65535;short short_num = 2000;}

经过测试,

...前面的常量池省略了,因为确实没有int的值,0: ldc           #15                 // String ggzx2: astore_1// 看这里,这里不像其他地方,这里后面直接是int的值了,这里直接sipush3: sipush        327676: istore_27: iconst_18: istore_39: ldc           #16                 // int 6553511: istore        413: sipush        200016: istore        518: return

欸, 说错了吗, 没有, 当我们把这个 32767 调大那么一丁点

  #16 = Integer            32768
...3: ldc           #16                 // int 32768

欸欸, 咋多一点就变了呢, 你观察这个数据, 他其实是 2^15 次方 = 32768, 而小于这个值并且大于 0 ,都会直接 push, 而不需要存储到静态常量池当中.

思维提升一下哈, 其他呢, 为什么其他在数据范围内也不需要存储到静态常量池吗?
首先, 我们了解一下, byte, short, boolean, int, char 都是咋存储的.
byte 实际上都是一个范围很小的数值
shotr 也是啊
boolean 就是 0 / 1
char 呢, 实际上也是数字, 最大为 65535, 对于 char 来说也是, 大于 32768 才会存储到静态常量池中.

来想想为什么不直接存呢?

我觉得吧, 可能是因为我们这个在 2^15 次方之内, 都可以直接通过数字来表达, 根本没有需要去再静态常量池中存储哇.
例如 ldc #16 假如 #16 这个位置在 2^15 次方之内, 都可以直接通过数字来表达, 根本没有需要去再静态常量池中存储哇.

到现在, 你想明白了普通的引用变量, 以及基本数据类型是如何存储的. 可能你还会好奇, static 变量如何存储哇, 首先对于基本类型和上面一致.
下面看看静态引用类型

public class ConstantPoolTest1 {private static Integer  obj = 1000;public static void main(String[] args) {}
}

... 这里是静态常量池的相关信息#3 = Fieldref           #4.#20         // org/example/jvm/ConstantPoolTest1.obj:Ljava/lang/Integer;
....
// 代表是静态初始化相关信息static {};Code:0: sipush        10003: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;6: putstatic     #3                  // Field obj:Ljava/lang/Integer;9: return

到这里可以看见, static 的信息也是存储在这里的.