本文概述:
静态常量池如何存储, 并且存储哪些信息
注: 本文不是按照理论来存储的, 本文注重于从现象得出结论
静态常量池是什么
静态常量池位于 Class 文件中, 当你对一个文件进行编译之后, 生成一个 class 文件, 里面存储了一个类的所有信息, 这个 class 字节码使得 Java 真正实现了跨平台, 一次编译, 到处运行.
Constant Pool 里面存储了一个类的所有对象”引用”和部分的基本数据类型的值 (如果你好奇, 具体如何存储的, 看上一篇文章), 这里简单说一下, 当创建一个对象引用, 在代码运行的时候, 引用指向的就是对象实例. 但是在文件中无法指向, 在 Class 文件中,对象引用指向的就是一个字符串, 这个字符串就是对象实例的全限定名, 通过这个全限定名, 在真正运行的时候就可以去寻找目标类了,这个字符串, 被称为符号引用
总而言之, 引用类型, 字面量, final 变量, 静态引用都是存储在这里的, 不过需要注意的是, 不要觉得静态常量池中存储的是真正的引用, 实际上这里的”引用”, 只是一个序号
![[Pasted image 20230316224731.png]]
比如说我定义了
String s = “JVM”原理,
我存储的是 s 引用吗, 不是, 他只是一个序号 #15 是 s 引用的序号, 这个”引用”指向了 #16 序号, 而这个 #16 指的就是一个普通的字符串.
所有引用类型, 包括 Class 对象, 都是这么存储的. 具体如存储的, 可以参考上一篇博客
这里我们做一个实验, 来测试一下
/**
* <p>
* 这里测试 Class 文件中的 ConstantPool 相关测试
* </p>
*
* @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.class
Last modified 2023-3-14; size 710 bytes
MD5 checksum 30896b5e6fccdb34ecc7c03e41cfbed5
Compiled from "ConstantPoolTest.java"
public class org.example.jvm.ConstantPoolTest
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #17.#43 // java/lang/Object."<init>":()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 <init>
#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 // "<init>":()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: ()V
flags: ACC_PUBLIC
Code:
stack=3, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: aload_0
5: bipush 110
7: putfield #2 // Field int_num:I
10: aload_0
11: bipush 97
13: putfield #3 // Field char_num:C
16: aload_0
17: bipush 120
19: putfield #4 // Field short_num:S
22: aload_0
23: ldc #5 // float 130.0f
25: putfield #6 // Field float_num:F
28: aload_0
29: ldc2_w #7 // double 140.0d
32: putfield #9 // Field double_num:D
35: aload_0
36: bipush 111
38: putfield #10 // Field byte_num:B
41: aload_0
42: ldc2_w #11 // long 3333l
45: putfield #13 // Field long_num:J
48: aload_0
49: iconst_1
50: putfield #14 // Field boolean_flag:Z
53: return
LineNumberTable:
line 13: 0
line 15: 4
line 16: 10
line 17: 16
line 18: 22
line 19: 28
line 20: 35
line 21: 41
line 23: 48
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=1, locals=2, args_size=1
0: ldc #15 // String ggzx
2: astore_1
3: return
LineNumberTable:
line 26: 0
line 27: 3
}
SourceFile: "ConstantPoolTest.java"
总结一下哈:
- 【final 修饰】的 8 种基本类型的值会进⼊常量池。
- 【⾮final 类型】（包括 static 的）的 8 种基本类型的值，只有【double、float、long】的值会进⼊常量池。
- 常量池中包含的字符串类型字⾯量（【双引号引起来的字符串值】）。
注意, 注意, 上面的其实是有问题的, 上面是某个有名的机构的出来的结果, 我做了几个实验, 第二步不完全对, 等下就讲, 说实话这里也是我误打误撞做实验的出来的
首先,这里你可能会有一个疑问, 为啥 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 ggzx
2: astore_1
// 看这里,这里不像其他地方,这里后面直接是int的值了,这里直接sipush
3: sipush 32767
6: istore_2
7: iconst_1
8: istore_3
9: ldc #16 // int 65535
11: istore 4
13: sipush 2000
16: istore 5
18: 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 1000
3: invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
6: putstatic #3 // Field obj:Ljava/lang/Integer;
9: return
到这里可以看见, static 的信息也是存储在这里的.