JAVA JVM指令集全部指令及解释

这是组成 Java 字节码的指令列表，Java 字节码是一种抽象机器语言，最终由 Java 虚拟机执行。  Java 字节码是由 Java 平台上运行的语言（尤其是 Java 编程语言）生成的。

Mnemonic	Opcode 操作码 (in hex)  （十六进制）	Opcode (in binary)  操作码（二进制）	Other bytes 其他字节 [count]: [operand labels] [计数]：[操作数标签]	Stack 堆 [before]→[after]  [之前]→[之后]	Description
aaload	32	0011 0010		arrayref, index → value 数组引用，索引 → 值	load onto the stack a reference from an array 将数组中的引用加载到堆栈上
aastore	53	0101 0011		arrayref, index, value → 数组引用、索引、值 →	store a reference in an array 将引用存储在数组中
aconst_null	01	0000 0001		→ null	push a null reference onto the stack 将空引用压入堆栈
aload	19	0001 1001	1: index	→ objectref	load a reference onto the stack from a local variable #index 从局部变量 #index 将引用加载到堆栈上
aload_0	2a	0010 1010		→ objectref	load a reference onto the stack from local variable 0 将局部变量 0 的引用加载到堆栈上
aload_1	2b	0010 1011		→ objectref	load a reference onto the stack from local variable 1 将局部变量 1 的引用加载到堆栈上
aload_2	2c	0010 1100		→ objectref	load a reference onto the stack from local variable 2 将局部变量 2 的引用加载到堆栈上
aload_3	2d	0010 1101		→ objectref	load a reference onto the stack from local variable 3 将局部变量 3 的引用加载到堆栈上
anewarray	bd	1011 1101	2: indexbyte1, indexbyte2 2：索引字节1，索引字节2	count → arrayref  计数 → 数组引用	create a new array of references of length count and component type identified by the class reference index (indexbyte1 << 8 | indexbyte2) in the constant pool 创建一个新的引用数组，其长度为 count，组件类型由常量池中的类引用索引 (indexbyte1 << 8 | indexbyte2) 标识
areturn	b0	1011 0000		objectref → [empty]  对象引用 → [空]	return a reference from a method 从方法返回引用
arraylength	be	1011 1110		arrayref → length  数组引用 → 长度	get the length of an array 获取数组的长度
astore	3a	0011 1010	1: index	objectref →	store a reference into a local variable #index 将引用存储到局部变量#index
astore_0	4b	0100 1011		objectref →	store a reference into local variable 0 将引用存储到局部变量 0 中
astore_1	4c	0100 1100		objectref →	store a reference into local variable 1 将引用存储到局部变量 1 中
astore_2	4d	0100 1101		objectref →	store a reference into local variable 2 将引用存储到局部变量 2 中
astore_3	4e	0100 1110		objectref →	store a reference into local variable 3 将引用存储到局部变量 3 中
athrow	bf	1011 1111		objectref → [empty], objectref 对象引用 → [空]，对象引用	throws an error or exception (notice that the rest of the stack is cleared, leaving only a reference to the Throwable) 抛出错误或异常（请注意，堆栈的其余部分已被清除，只留下对 Throwable 的引用）
baload	33	0011 0011		arrayref, index → value 数组引用，索引 → 值	load a byte or Boolean value from an array 从数组加载字节或布尔值
bastore	54	0101 0100		arrayref, index, value → 数组引用、索引、值 →	store a byte or Boolean value into an array 将字节或布尔值存储到数组中
bipush	10	0001 0000	1: byte	→ value	push a byte onto the stack as an integer value 将一个字节作为整数值压入堆栈
breakpoint	ca	1100 1010			reserved for breakpoints in Java debuggers; should not appear in any class file 为 Java 调试器中的断点保留；不应出现在任何类文件中
caload	34	0011 0100		arrayref, index → value 数组引用，索引 → 值	load a char from an array 从数组加载一个字符
castore	55	0101 0101		arrayref, index, value → 数组引用、索引、值 →	store a char into an array 将 char 存储到数组中
checkcast	c0	1100 0000	2: indexbyte1, indexbyte2 2：索引字节1，索引字节2	objectref → objectref  对象引用 → 对象引用	checks whether an objectref is of a certain type, the class reference of which is in the constant pool at index (indexbyte1 << 8 | indexbyte2) 检查 objectref 是否属于某种类型，其类引用位于常量池中的索引处 (indexbyte1 << 8 | indexbyte2)
d2f	90	1001 0000		value → result  值→结果	convert a double to a float 将双精度型转换为浮点型
d2i	8e	1000 1110		value → result  值→结果	convert a double to an int 将 double 转换为 int
d2l	8f	1000 1111		value → result  值→结果	convert a double to a long 将双精度数转换为长整型
dadd	63	0110 0011		value1, value2 → result 值1，值2→结果	add two doubles  添加两个双打
daload	31	0011 0001		arrayref, index → value 数组引用，索引 → 值	load a double from an array 从数组中加载双精度值
dastore	52	0101 0010		arrayref, index, value → 数组引用、索引、值 →	store a double into an array 将双精度值存储到数组中
dcmpg	98	1001 1000		value1, value2 → result 值1，值2→结果	compare two doubles, 1 on NaN 比较两个双精度数，1 与 NaN
dcmpl	97	1001 0111		value1, value2 → result 值1，值2→结果	compare two doubles, -1 on NaN 比较两个双精度数，NaN 时为 -1
dconst_0	0e	0000 1110		→ 0.0	push the constant 0.0 (a double) onto the stack 将常量 0.0（双精度）压入堆栈
dconst_1	0f	0000 1111		→ 1.0	push the constant 1.0 (a double) onto the stack 将常量 1.0（双精度）压入堆栈
ddiv	6f	0110 1111		value1, value2 → result 值1，值2→结果	divide two doubles  除两个双打
dload	18	0001 1000	1: index	→ value	load a double value from a local variable #index 从局部变量 #index 加载双精度值
dload_0	26	0010 0110		→ value	load a double from local variable 0 从局部变量 0 加载双精度值
dload_1	27	0010 0111		→ value	load a double from local variable 1 从局部变量 1 加载双精度值
dload_2	28	0010 1000		→ value	load a double from local variable 2 从局部变量 2 加载双精度值
dload_3	29	0010 1001		→ value	load a double from local variable 3 从局部变量 3 加载双精度值
dmul	6b	0110 1011		value1, value2 → result 值1，值2→结果	multiply two doubles  两个双精度数相乘
dneg	77	0111 0111		value → result  值→结果	negate a double  否定双重
drem	73	0111 0011		value1, value2 → result 值1，值2→结果	get the remainder from a division between two doubles 得到两个双精度数相除的余数
dreturn	af	1010 1111		value → [empty]  值 → [空]	return a double from a method 从方法返回双精度值
dstore	39	0011 1001	1: index	value →	store a double value into a local variable #index 将双精度值存储到局部变量#index
dstore_0	47	0100 0111		value →	store a double into local variable 0 将 double 存储到局部变量 0 中
dstore_1	48	0100 1000		value →	store a double into local variable 1 将双精度值存储到局部变量 1 中
dstore_2	49	0100 1001		value →	store a double into local variable 2 将 double 存储到局部变量 2 中
dstore_3	4a	0100 1010		value →	store a double into local variable 3 将 double 存储到局部变量 3 中
dsub	67	0110 0111		value1, value2 → result 值1，值2→结果	subtract a double from another 从另一个中减去一个双精度
dup	59	0101 1001		value → value, value 值→值、值	duplicate the value on top of the stack 复制堆栈顶部的值
dup_x1	5a	0101 1010		value2, value1 → value1, value2, value1 值 2、值 1 → 值 1、值 2、值 1	insert a copy of the top value into the stack two values from the top. value1 and value2 must not be of the type double or long. 将顶部值的副本插入到距顶部两个值的堆栈中。 value1 和 value2 不得为 double 或 long 类型。
dup_x2	5b	0101 1011		value3, value2, value1 → value1, value3, value2, value1 值 3、值 2、值 1 → 值 1、值 3、值 2、值 1	insert a copy of the top value into the stack two (if value2 is double or long it takes up the entry of value3, too) or three values (if value2 is neither double nor long) from the top 将顶部值的副本插入到堆栈中 从顶部开始两个值（如果 value2 是 double 或 long，它也会占用 value3 的条目）或三个值（如果 value2 既不是 double 也不是 long）
dup2	5c	0101 1100		{value2, value1} → {value2, value1}, {value2, value1} {值2，值1} → {值2，值1}，{值2，值1}	duplicate top two stack words (two values, if value1 is not double nor long; a single value, if value1 is double or long) 重复顶部两个堆栈字（如果 value1 不是 double 也不是 long，则为两个值；如果 value1 为 double 或 long，则为单个值）
dup2_x1	5d	0101 1101		value3, {value2, value1} → {value2, value1}, value3, {value2, value1} 值3，{值2，值1} → {值2，值1}，值3，{值2，值1}	duplicate two words and insert beneath third word (see explanation above) 复制两个单词并插入第三个单词下方（参见上面的解释）
dup2_x2	5e	0101 1110		{value4, value3}, {value2, value1} → {value2, value1}, {value4, value3}, {value2, value1} {值4，值3}，{值2，值1} → {值2，值1}，{值4，值3}，{值2，值1}	duplicate two words and insert beneath fourth word 复制两个单词并插入到第四个单词下方
f2d	8d	1000 1101		value → result  值→结果	convert a float to a double 将浮点型转换为双精度型
f2i	8b	1000 1011		value → result  值→结果	convert a float to an int 将 float 转换为 int
f2l	8c	1000 1100		value → result  值→结果	convert a float to a long 将 float 转换为 long
fadd	62	0110 0010		value1, value2 → result 值1，值2→结果	add two floats  添加两个浮点数
faload	30	0011 0000		arrayref, index → value 数组引用，索引 → 值	load a float from an array 从数组中加载一个浮点数
fastore	51	0101 0001		arrayref, index, value → 数组引用、索引、值 →	store a float in an array 将浮点数存储在数组中
fcmpg	96	1001 0110		value1, value2 → result 值1，值2→结果	compare two floats, 1 on NaN 比较两个浮点数，1 与 NaN
fcmpl	95	1001 0101		value1, value2 → result 值1，值2→结果	compare two floats, -1 on NaN 比较两个浮点数，NaN 时为 -1
fconst_0	0b	0000 1011		→ 0.0f	push 0.0f on the stack 将 0.0f 压入堆栈
fconst_1	0c	0000 1100		→ 1.0f	push 1.0f on the stack 将 1.0f 压入堆栈
fconst_2	0d	0000 1101		→ 2.0f	push 2.0f on the stack 将 2.0f 压入堆栈
fdiv	6e	0110 1110		value1, value2 → result 值1，值2→结果	divide two floats  划分两个浮点数
fload	17	0001 0111	1: index	→ value	load a float value from a local variable #index 从局部变量 #index 加载浮点值
fload_0	22	0010 0010		→ value	load a float value from local variable 0 从局部变量 0 加载浮点值
fload_1	23	0010 0011		→ value	load a float value from local variable 1 从局部变量 1 加载浮点值
fload_2	24	0010 0100		→ value	load a float value from local variable 2 从局部变量 2 加载浮点值
fload_3	25	0010 0101		→ value	load a float value from local variable 3 从局部变量 3 加载浮点值
fmul	6a	0110 1010		value1, value2 → result 值1，值2→结果	multiply two floats  两个浮点数相乘
fneg	76	0111 0110		value → result  值→结果	negate a float  否定浮动
frem	72	0111 0010		value1, value2 → result 值1，值2→结果	get the remainder from a division between two floats 获取两个浮点数相除的余数
freturn	ae	1010 1110		value → [empty]  值 → [空]	return a float  返回一个浮点数
fstore	38	0011 1000	1: index	value →	store a float value into a local variable #index 将浮点值存储到局部变量#index
fstore_0	43	0100 0011		value →	store a float value into local variable 0 将浮点值存储到局部变量 0 中
fstore_1	44	0100 0100		value →	store a float value into local variable 1 将浮点值存储到局部变量 1 中
fstore_2	45	0100 0101		value →	store a float value into local variable 2 将浮点值存储到局部变量 2 中
fstore_3	46	0100 0110		value →	store a float value into local variable 3 将浮点值存储到局部变量 3 中
fsub	66	0110 0110		value1, value2 → result 值1，值2→结果	subtract two floats  减去两个浮点数
getfield	b4	1011 0100	2: indexbyte1, indexbyte2 2：索引字节1，索引字节2	objectref → value  对象引用 → 值	get a field value of an object objectref, where the field is identified by field reference in the constant pool index (indexbyte1 << 8 | indexbyte2) 获取对象objectref的某个字段值，该字段由常量池索引中的字段引用来标识(indexbyte1 << 8 | indexbyte2)
getstatic	b2	1011 0010	2: indexbyte1, indexbyte2 2：索引字节1，索引字节2	→ value	get a static field value of a class, where the field is identified by field reference in the constant pool index (indexbyte1 << 8 | indexbyte2) 获取一个类的静态字段值，该字段由常量池索引中的字段引用标识（indexbyte1 << 8 | indexbyte2）
goto	a7	1010 0111	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	[no change]	goes to another instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 转到branchoffset处的另一条指令（由无符号字节branchbyte1 << 8 |branchbyte2构造的有符号短指令）
goto_w	c8	1100 1000	4: branchbyte1, branchbyte2, branchbyte3, branchbyte4 4：分支字节1、分支字节2、分支字节3、分支字节4	[no change]	goes to another instruction at branchoffset (signed int constructed from unsigned bytes branchbyte1 << 24 | branchbyte2 << 16 | branchbyte3 << 8 | branchbyte4) 转到branchoffset处的另一条指令（从无符号字节构造的有符号intbranchbyte1 << 24 |branchbyte2 << 16 |branchbyte3 << 8 |branchbyte4）
i2b	91	1001 0001		value → result  值→结果	convert an int into a byte 将 int 转换为 byte
i2c	92	1001 0010		value → result  值→结果	convert an int into a character 将 int 转换为字符
i2d	87	1000 0111		value → result  值→结果	convert an int into a double 将 int 转换为 double
i2f	86	1000 0110		value → result  值→结果	convert an int into a float 将 int 转换为 float
i2l	85	1000 0101		value → result  值→结果	convert an int into a long 将 int 转换为 long
i2s	93	1001 0011		value → result  值→结果	convert an int into a short 将 int 转换为短整型
iadd	60	0110 0000		value1, value2 → result 值1，值2→结果	add two ints
iaload	2e	0010 1110		arrayref, index → value 数组引用，索引 → 值	load an int from an array 从数组中加载一个 int
iand	7e	0111 1110		value1, value2 → result 值1，值2→结果	perform a bitwise AND on two integers 对两个整数执行按位 AND
iastore	4f	0100 1111		arrayref, index, value → 数组引用、索引、值 →	store an int into an array 将 int 存储到数组中
iconst_m1	02	0000 0010		→ -1	load the int value −1 onto the stack 将 int 值 -1 加载到堆栈上
iconst_0	03	0000 0011		→ 0	load the int value 0 onto the stack 将 int 值 0 加载到堆栈上
iconst_1	04	0000 0100		→ 1	load the int value 1 onto the stack 将 int 值 1 加载到堆栈上
iconst_2	05	0000 0101		→ 2	load the int value 2 onto the stack 将 int 值 2 加载到堆栈上
iconst_3	06	0000 0110		→ 3	load the int value 3 onto the stack 将 int 值 3 加载到堆栈上
iconst_4	07	0000 0111		→ 4	load the int value 4 onto the stack 将 int 值 4 加载到堆栈上
iconst_5	08	0000 1000		→ 5	load the int value 5 onto the stack 将 int 值 5 加载到堆栈上
idiv	6c	0110 1100		value1, value2 → result 值1，值2→结果	divide two integers  除两个整数
if_acmpeq	a5	1010 0101	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	value1, value2 →  值 1、值 2 →	if references are equal, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 如果引用相等，则跳转到branchoffset处的指令（由无符号字节branchbyte1 << 8 |branchbyte2构造的有符号短指令）
if_acmpne	a6	1010 0110	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	value1, value2 →  值 1、值 2 →	if references are not equal, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 如果引用不相等，则分支到branchoffset处的指令（由无符号字节branchbyte1 << 8 |branchbyte2构造的有符号短整型）
if_icmpeq	9f	1001 1111	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	value1, value2 →  值 1、值 2 →	if ints are equal, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 如果整数相等，则跳转到branchoffset处的指令（由无符号字节branchbyte1 << 8 |branchbyte2构造的有符号短整型）
if_icmpge	a2	1010 0010	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	value1, value2 →  值 1、值 2 →	if value1 is greater than or equal to value2, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 如果 value1 大于或等于 value2，则跳转到branchoffset处的指令（由无符号字节构造的有符号短值branchbyte1 << 8 |branchbyte2）
if_icmpgt	a3	1010 0011	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	value1, value2 →  值 1、值 2 →	if value1 is greater than value2, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 如果 value1 大于 value2，则跳转到branchoffset处的指令（由无符号字节构造的有符号短值branchbyte1 << 8 |branchbyte2）
if_icmple	a4	1010 0100	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	value1, value2 →  值 1、值 2 →	if value1 is less than or equal to value2, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 如果 value1 小于或等于 value2，则跳转到branchoffset处的指令（由无符号字节构造的有符号短值branchbyte1 << 8 |branchbyte2）
if_icmplt	a1	1010 0001	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	value1, value2 →  值 1、值 2 →	if value1 is less than value2, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 如果 value1 小于 value2，则跳转到branchoffset处的指令（由无符号字节构造的有符号短值branchbyte1 << 8 |branchbyte2）
if_icmpne	a0	1010 0000	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	value1, value2 →  值 1、值 2 →	if ints are not equal, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 如果整数不相等，则跳转到branchoffset处的指令（由无符号字节branchbyte1<<8|branchbyte2构造的有符号short）
ifeq	99	1001 1001	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	value →	if value is 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 如果值为 0，则跳转到branchoffset处的指令（由无符号字节branchbyte1 << 8 |branchbyte2构造的有符号短指令）
ifge	9c	1001 1100	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	value →	if value is greater than or equal to 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 如果值大于或等于 0，则跳转到branchoffset处的指令（由无符号字节构造的有符号短值branchbyte1 << 8 |branchbyte2）
ifgt	9d	1001 1101	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	value →	if value is greater than 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 如果值大于 0，则跳转到branchoffset处的指令（由无符号字节branchbyte1 << 8 |branchbyte2构造的有符号短指令）
ifle	9e	1001 1110	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	value →	if value is less than or equal to 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 如果值小于或等于 0，则跳转到branchoffset处的指令（由无符号字节构造的有符号短值branchbyte1 << 8 |branchbyte2）
iflt	9b	1001 1011	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	value →	if value is less than 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 如果值小于 0，则跳转到branchoffset处的指令（由无符号字节branchbyte1 << 8 |branchbyte2构造的有符号短指令）
ifne	9a	1001 1010	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	value →	if value is not 0, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 如果 value 不为 0，则跳转到branchoffset处的指令（由无符号字节branchbyte1 << 8 |branchbyte2构造的有符号短指令）
ifnonnull	c7	1100 0111	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	value →	if value is not null, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 如果值不为空，则跳转到branchoffset处的指令（由无符号字节branchbyte1 << 8 |branchbyte2构造的有符号短指令）
ifnull	c6	1100 0110	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	value →	if value is null, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) 如果值为空，则跳转到branchoffset处的指令（由无符号字节branchbyte1 << 8 |branchbyte2构造的有符号短指令）
iinc	84	1000 0100	2: index, const  2：索引，常量	[No change]	increment local variable #index by signed byte const 按有符号字节常量递增局部变量#index
iload	15	0001 0101	1: index	→ value	load an int value from a local variable #index 从局部变量 #index 加载 int 值
iload_0	1a	0001 1010		→ value	load an int value from local variable 0 从局部变量 0 加载 int 值
iload_1	1b	0001 1011		→ value	load an int value from local variable 1 从局部变量 1 加载 int 值
iload_2	1c	0001 1100		→ value	load an int value from local variable 2 从局部变量 2 加载 int 值
iload_3	1d	0001 1101		→ value	load an int value from local variable 3 从局部变量 3 加载 int 值
impdep1	fe	1111 1110			reserved for implementation-dependent operations within debuggers; should not appear in any class file 保留用于调试器内依赖于实现的操作；不应出现在任何类文件中
impdep2	ff	1111 1111			reserved for implementation-dependent operations within debuggers; should not appear in any class file 保留用于调试器内依赖于实现的操作；不应出现在任何类文件中
imul	68	0110 1000		value1, value2 → result 值1，值2→结果	multiply two integers  两个整数相乘
ineg	74	0111 0100		value → result  值→结果	negate int
instanceof	c1	1100 0001	2: indexbyte1, indexbyte2 2：索引字节1，索引字节2	objectref → result  对象引用 → 结果	determines if an object objectref is of a given type, identified by class reference index in constant pool (indexbyte1 << 8 | indexbyte2) 确定对象 objectref 是否属于给定类型，由常量池中的类引用索引标识 (indexbyte1 << 8 | indexbyte2)
invokedynamic	ba	1011 1010	4: indexbyte1, indexbyte2, 0, 0 4: 索引字节1, 索引字节2, 0, 0	[arg1, arg2, ...] → result [arg1, arg2, ...] → 结果	invokes a dynamic method and puts the result on the stack (might be void); the method is identified by method reference index in constant pool (indexbyte1 << 8 | indexbyte2) 调用动态方法并将结果放入堆栈（可能为空）；该方法通过常量池中的方法引用索引来标识（indexbyte1 << 8 | indexbyte2）
invokeinterface	b9	1011 1001	4: indexbyte1, indexbyte2, count, 0 4：索引字节1，索引字节2，计数，0	objectref, [arg1, arg2, ...] → result objectref, [arg1, arg2, ...] → 结果	invokes an interface method on object objectref and puts the result on the stack (might be void); the interface method is identified by method reference index in constant pool (indexbyte1 << 8 | indexbyte2) 调用对象 objectref 上的接口方法并将结果放入堆栈（可能为 void）；接口方法通过常量池中的方法引用索引来标识（indexbyte1 << 8 | indexbyte2）
invokespecial	b7	1011 0111	2: indexbyte1, indexbyte2 2：索引字节1，索引字节2	objectref, [arg1, arg2, ...] → result objectref, [arg1, arg2, ...] → 结果	invoke instance method on object objectref and puts the result on the stack (might be void); the method is identified by method reference index in constant pool (indexbyte1 << 8 | indexbyte2) 调用对象 objectref 上的实例方法并将结果放入堆栈（可能为 void）；该方法通过常量池中的方法引用索引来标识（indexbyte1 << 8 | indexbyte2）
invokestatic	b8	1011 1000	2: indexbyte1, indexbyte2 2：索引字节1，索引字节2	[arg1, arg2, ...] → result [arg1, arg2, ...] → 结果	invoke a static method and puts the result on the stack (might be void); the method is identified by method reference index in constant pool (indexbyte1 << 8 | indexbyte2) 调用静态方法并将结果放入堆栈（可能为空）；该方法通过常量池中的方法引用索引来标识（indexbyte1 << 8 | indexbyte2）
invokevirtual	b6	1011 0110	2: indexbyte1, indexbyte2 2：索引字节1，索引字节2	objectref, [arg1, arg2, ...] → result objectref, [arg1, arg2, ...] → 结果	invoke virtual method on object objectref and puts the result on the stack (might be void); the method is identified by method reference index in constant pool (indexbyte1 << 8 | indexbyte2) 调用对象 objectref 上的虚拟方法并将结果放入堆栈（可能为 void）；该方法通过常量池中的方法引用索引来标识（indexbyte1 << 8 | indexbyte2）
ior	80	1000 0000		value1, value2 → result 值1，值2→结果	bitwise int OR  按位整数或
irem	70	0111 0000		value1, value2 → result 值1，值2→结果	logical int remainder  逻辑整数余数
ireturn	ac	1010 1100		value → [empty]  值 → [空]	return an integer from a method 从方法返回一个整数
ishl	78	0111 1000		value1, value2 → result 值1，值2→结果	int shift left  int 左移
ishr	7a	0111 1010		value1, value2 → result 值1，值2→结果	int arithmetic shift right int 算术右移
istore	36	0011 0110	1: index	value →	store int value into variable #index 将 int 值存储到变量#index
istore_0	3b	0011 1011		value →	store int value into variable 0 将 int 值存储到变量 0 中
istore_1	3c	0011 1100		value →	store int value into variable 1 将 int 值存储到变量 1 中
istore_2	3d	0011 1101		value →	store int value into variable 2 将 int 值存储到变量 2 中
istore_3	3e	0011 1110		value →	store int value into variable 3 将 int 值存储到变量 3 中
isub	64	0110 0100		value1, value2 → result 值1，值2→结果	int subtract
iushr	7c	0111 1100		value1, value2 → result 值1，值2→结果	int logical shift right  int 逻辑右移
ixor	82	1000 0010		value1, value2 → result 值1，值2→结果	int xor
jsr†	a8	1010 1000	2: branchbyte1, branchbyte2 2：分支字节1，分支字节2	→ address	jump to subroutine at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 | branchbyte2) and place the return address on the stack 跳转到branchoffset处的子例程（由无符号字节branchbyte1 << 8 |branchbyte2构造的有符号短整型）并将返回地址放在堆栈上
jsr_w†	c9	1100 1001	4: branchbyte1, branchbyte2, branchbyte3, branchbyte4 4：分支字节1、分支字节2、分支字节3、分支字节4	→ address	jump to subroutine at branchoffset (signed int constructed from unsigned bytes branchbyte1 << 24 | branchbyte2 << 16 | branchbyte3 << 8 | branchbyte4) and place the return address on the stack 跳转到branchoffset处的子例程（由无符号字节branchbyte1 << 24 |branchbyte2 << 16 |branchbyte3 << 8 |branchbyte4构造的signed int）并将返回地址放入堆栈
l2d	8a	1000 1010		value → result  值→结果	convert a long to a double 将 long 转换为 double
l2f	89	1000 1001		value → result  值→结果	convert a long to a float 将 long 转换为 float
l2i	88	1000 1000		value → result  值→结果	convert a long to a int 将 long 转换为 int
ladd	61	0110 0001		value1, value2 → result 值1，值2→结果	add two longs  添加两个长整型
laload	2f	0010 1111		arrayref, index → value 数组引用，索引 → 值	load a long from an array 从数组中加载一个 long
land	7f	0111 1111		value1, value2 → result 值1，值2→结果	bitwise AND of two longs 两个长整型的按位与
lastore	50	0101 0000		arrayref, index, value → 数组引用、索引、值 →	store a long to an array 将 long 值存储到数组中
lcmp	94	1001 0100		value1, value2 → result 值1，值2→结果	push 0 if the two longs are the same, 1 if value1 is greater than value2, -1 otherwise 如果两个长整型相同则推入 0，如果 value1 大于 value2，则推入 1，否则推入 -1
lconst_0	09	0000 1001		→ 0L	push 0L (the number zero with type long) onto the stack 将 0L（long 类型的数字零）压入堆栈
lconst_1	0a	0000 1010		→ 1L	push 1L (the number one with type long) onto the stack 将 1L（long 类型的数字）压入堆栈
ldc	12	0001 0010	1: index	→ value	push a constant #index from a constant pool (String, int, float, Class, java.lang.invoke.MethodType, java.lang.invoke.MethodHandle, or a dynamically-computed constant) onto the stack 将常量 #index 从常量池（String、int、float、Class、java.lang.invoke.MethodType、java.lang.invoke.MethodHandle 或动态计算常量）推送到堆栈
ldc_w	13	0001 0011	2: indexbyte1, indexbyte2 2：索引字节1，索引字节2	→ value	push a constant #index from a constant pool (String, int, float, Class, java.lang.invoke.MethodType, java.lang.invoke.MethodHandle, or a dynamically-computed constant) onto the stack (wide index is constructed as indexbyte1 << 8 | indexbyte2) 将常量 #index 从常量池（String、int、float、Class、java.lang.invoke.MethodType、java.lang.invoke.MethodHandle 或动态计算常量）推送到堆栈（宽索引构造为索引字节1 << 8 | 索引字节2)
ldc2_w	14	0001 0100	2: indexbyte1, indexbyte2 2：索引字节1，索引字节2	→ value	push a constant #index from a constant pool (double, long, or a dynamically-computed constant) onto the stack (wide index is constructed as indexbyte1 << 8 | indexbyte2) 将常量 #index 从常量池（双精度、长整型或动态计算常量）推入堆栈（宽索引构造为 indexbyte1 << 8 | indexbyte2）
ldiv	6d	0110 1101		value1, value2 → result 值1，值2→结果	divide two longs  除两个长数
lload	16	0001 0110	1: index	→ value	load a long value from a local variable #index 从局部变量 #index 加载一个长值
lload_0	1e	0001 1110		→ value	load a long value from a local variable 0 从局部变量 0 加载一个长整型值
lload_1	1f	0001 1111		→ value	load a long value from a local variable 1 从局部变量 1 加载一个 long 值
lload_2	20	0010 0000		→ value	load a long value from a local variable 2 从局部变量加载一个长整型值 2
lload_3	21	0010 0001		→ value	load a long value from a local variable 3 从局部变量加载一个长整型值 3
lmul	69	0110 1001		value1, value2 → result 值1，值2→结果	multiply two longs  两个长整型相乘
lneg	75	0111 0101		value → result  值→结果	negate a long  否定长
lookupswitch	ab	1010 1011	8+: <0–3 bytes padding>, defaultbyte1, defaultbyte2, defaultbyte3, defaultbyte4, npairs1, npairs2, npairs3, npairs4, match-offset pairs... 8+：<0–3 字节填充>、defaultbyte1、defaultbyte2、defaultbyte3、defaultbyte4、npairs1、npairs2、npairs3、npairs4、匹配偏移对...	key →	a target address is looked up from a table using a key and execution continues from the instruction at that address 使用键从表中查找目标地址，然后从该地址处的指令继续执行
lor	81	1000 0001		value1, value2 → result 值1，值2→结果	bitwise OR of two longs 两个长整型数的按位或
lrem	71	0111 0001		value1, value2 → result 值1，值2→结果	remainder of division of two longs 两个长整型相除的余数
lreturn	ad	1010 1101		value → [empty]  值 → [空]	return a long value  返回一个长值
lshl	79	0111 1001		value1, value2 → result 值1，值2→结果	bitwise shift left of a long value1 by int value2 positions 将 long value1 按位左移 int value2 个位置
lshr	7b	0111 1011		value1, value2 → result 值1，值2→结果	bitwise shift right of a long value1 by int value2 positions 将 long value1 按位右移 int value2 个位置
lstore	37	0011 0111	1: index	value →	store a long value in a local variable #index 将长值存储在局部变量#index中
lstore_0	3f	0011 1111		value →	store a long value in a local variable 0 将长整型值存储在局部变量 0 中
lstore_1	40	0100 0000		value →	store a long value in a local variable 1 将 long 值存储在局部变量 1 中
lstore_2	41	0100 0001		value →	store a long value in a local variable 2 将 long 值存储在局部变量 2 中
lstore_3	42	0100 0010		value →	store a long value in a local variable 3 将 long 值存储在局部变量中 3
lsub	65	0110 0101		value1, value2 → result 值1，值2→结果	subtract two longs  减去两个长整型
lushr	7d	0111 1101		value1, value2 → result 值1，值2→结果	bitwise shift right of a long value1 by int value2 positions, unsigned 将 long value1 按位右移 int value2 个位置，无符号
lxor	83	1000 0011		value1, value2 → result 值1，值2→结果	bitwise XOR of two longs 两个长整型的按位异或
monitorenter	c2	1100 0010		objectref →	enter monitor for object ("grab the lock" – start of synchronized() section) 输入对象监视器（“抓住锁”——synchronized() 部分的开始）
monitorexit	c3	1100 0011		objectref →	exit monitor for object ("release the lock" – end of synchronized() section) 退出对象监视器（“释放锁”——synchronized() 部分结束）
multianewarray	c5	1100 0101	3: indexbyte1, indexbyte2, dimensions 3：索引字节1，索引字节2，维度	count1, [count2,...] → arrayref	create a new array of dimensions dimensions of type identified by class reference in constant pool index (indexbyte1 << 8 | indexbyte2); the sizes of each dimension is identified by count1, [count2, etc.] 创建一个新的维度数组，其类型由常量池索引中的类引用标识（indexbyte1 << 8 | indexbyte2）；每个维度的大小由 count1、[count2 等] 标识
new	bb	1011 1011	2: indexbyte1, indexbyte2 2：索引字节1，索引字节2	→ objectref	create new object of type identified by class reference in constant pool index (indexbyte1 << 8 | indexbyte2) 创建由常量池索引中的类引用标识的类型的新对象 (indexbyte1 << 8 | indexbyte2)
newarray	bc	1011 1100	1: atype	count → arrayref  计数 → 数组引用	create new array with count elements of primitive type identified by atype 创建新数组，其中包含由 atype 标识的基本类型的 count 元素
nop	00	0000 0000		[No change]	perform no operation  不执行任何操作
pop	57	0101 0111		value →	discard the top value on the stack 丢弃堆栈顶部的值
pop2	58	0101 1000		{value2, value1} →  {值2，值1} →	discard the top two values on the stack (or one value, if it is a double or long) 丢弃堆栈中最上面的两个值（或者一个值，如果它是 double 或 long）
putfield	b5	1011 0101	2: indexbyte1, indexbyte2 2：索引字节1，索引字节2	objectref, value →  对象引用，值 →	set field to value in an object objectref, where the field is identified by a field reference index in constant pool (indexbyte1 << 8 | indexbyte2) 将字段设置为对象objectref中的值，其中该字段由常量池中的字段引用索引标识（indexbyte1 << 8 | indexbyte2）
putstatic	b3	1011 0011	2: indexbyte1, indexbyte2 2：索引字节1，索引字节2	value →	set static field to value in a class, where the field is identified by a field reference index in constant pool (indexbyte1 << 8 | indexbyte2) 将静态字段设置为类中的值，其中该字段由常量池中的字段引用索引标识（indexbyte1 << 8 | indexbyte2）
ret†	a9	1010 1001	1: index	[No change]	continue execution from address taken from a local variable #index (the asymmetry with jsr is intentional) 从局部变量 #index 获取的地址继续执行（与 jsr 的不对称是故意的）
return	b1	1011 0001		→ [empty]	return void from method  从方法返回 void
saload	35	0011 0101		arrayref, index → value 数组引用，索引 → 值	load short from array  从数组加载短路
sastore	56	0101 0110		arrayref, index, value → 数组引用、索引、值 →	store short to array  存储短到数组
sipush	11	0001 0001	2: byte1, byte2  2：字节1，字节2	→ value	push a short onto the stack as an integer value 将 Short 作为整数值压入堆栈
swap	5f	0101 1111		value2, value1 → value1, value2 值2，值1 → 值1，值2	swaps two top words on the stack (note that value1 and value2 must not be double or long) 交换堆栈上的两个顶部字（请注意 value1 和 value2 不得为 double 或 long）
tableswitch	aa	1010 1010	16+: [0–3 bytes padding], defaultbyte1, defaultbyte2, defaultbyte3, defaultbyte4, lowbyte1, lowbyte2, lowbyte3, lowbyte4, highbyte1, highbyte2, highbyte3, highbyte4, jump offsets... 16+：[0–3 字节填充]、defaultbyte1、defaultbyte2、defaultbyte3、defaultbyte4、lowbyte1、lowbyte2、lowbyte3、lowbyte4、highbyte1、highbyte2、highbyte3、highbyte4、跳转偏移量...	index →	continue execution from an address in the table at offset index 从表中偏移索引处的地址继续执行
wide	c4	1100 0100	3/5: opcode, indexbyte1, indexbyte2 3/5：操作码，索引字节1，索引字节2 or iinc, indexbyte1, indexbyte2, countbyte1, countbyte2 iinc、索引字节 1、索引字节 2、计数字节 1、计数字节 2	[same as for corresponding instructions] [与相应说明相同]	execute opcode, where opcode is either iload, fload, aload, lload, dload, istore, fstore, astore, lstore, dstore, or ret, but assume the index is 16 bit; or execute iinc, where the index is 16 bits and the constant to increment by is a signed 16 bit short 执行操作码，其中操作码是 iload、fload、aload、lload、dload、istore、fstore、astore、lstore、dstore 或 ret，但假设索引是 16 位；或执行 iinc，其中索引为 16 位，并且要递增的常量是有符号 16 位短整型
(no name)	cb-fd				these values are currently unassigned for opcodes and are reserved for future use 这些值当前未分配给操作码，并保留以供将来使用

  AALOAD,       // 从数组中加载一个元素，并将其压入堆栈
  AASTORE,      // 将堆栈顶的值存入数组中的一个元素中
  ACONST_NULL,  // 将 null 常量压入堆栈
  ALOAD,        // 将一个引用类型的变量加载到堆栈中
  ALOAD_0,      // 将第 0 个引用类型的局部变量加载到堆栈中
  ALOAD_1,      // 将第 1 个引用类型的局部变量加载到堆栈中
  ALOAD_2,      // 将第 2 个引用类型的局部变量加载到堆栈中
  ALOAD_3,      // 将第 3 个引用类型的局部变量加载到堆栈中
  ANEWARRAY,  // 创建一个引用类型的数组，并将其引用压入堆栈
  ARETURN,  // 从子函数中返回，并将返回值（如果有）压入栈顶
  ARRAYLENGTH,  // 获取数组的长度，并将其压入堆栈
  ASTORE,       // 将堆栈顶的引用类型值存入局部变量中
  ASTORE_0,  // 将堆栈顶的引用类型值存入第 0 个引用类型的局部变量中
  ASTORE_1,  // 将堆栈顶的引用类型值存入第 1 个引用类型的局部变量中
  ASTORE_2,  // 将堆栈顶的引用类型值存入第 2 个引用类型的局部变量中
  ASTORE_3,  // 将堆栈顶的引用类型值存入第 3 个引用类型的局部变量中
  ATHROW,  // 抛出一个异常
  BALOAD,  // 从数组中加载一个 byte/boolean 类型的元素，并将其压入堆栈
  BASTORE,  // 将堆栈顶的 byte/boolean 类型的值存入数组中的一个元素中
  BIPUSH,      // 将一个 byte 类型的常量压入堆栈
  BREAKPOINT,  // 用于调试，目前没有具体的作用
  CALOAD,  // 从数组中加载一个 char 类型的元素，并将其压入堆栈
  CASTORE,  // 将堆栈顶的 char 类型的值存入数组中的一个元素中
  CHECKCAST,  // 检查堆栈顶的对象是否是某个类的实例，如果不是则抛出
              // ClassCastException
  D2F,  // 将 double 类型的数值转换为 float 类型的数值，并将其压入堆栈
  D2I,  // 将 double 类型的数值转换为 int 类型的数值，并将其压入堆栈
  D2L,  // 将 double 类型的数值转换为 long 类型的数值，并将其压入堆栈
  DADD,  // 将堆栈顶的 double 类型的值加上堆栈第二个位置的 double
         // 类型的值，并将结果压入堆栈
  DALOAD,  // 从数组中加载一个 double 类型的元素，并将其压入堆栈
  DASTORE,  // 将堆栈顶的 double 类型的值存入数组中的一个元素中
  DCMPG,  // 比较堆栈顶的两个 double
          // 类型的值的大小，如果第一个值大于第二个值则将 -1 压入堆栈，否则将 1
          // 压入堆栈
  DCMPL,  // 比较堆栈顶的两个 double
          // 类型的值的大小，如果第一个值小于第二个值则将 -1 压入堆栈，否则将 1
          // 压入堆栈
  DCONST_0,  // 将 double 类型的 0.0 压入堆栈
  DCONST_1,  // 将 double 类型的 1.0 压入堆栈
  DDIV,  // 将堆栈顶的两个 double 类型的值相除，并将结果压入堆栈
  DLOAD,  // 从局部变量表中加载一个 double 类型的值，并将其压入堆栈
  DLOAD_0,  // 从局部变量表中加载第一个 double 类型的值，并将其压入堆栈
  DLOAD_1,  // 从局本变量表中加载第二个 double 类型的值，并将其压入堆栈
  DLOAD_2,  // 从局本变量表中加载第三个 double 类型的值，并将其压入堆栈
  DLOAD_3,  // 从局本变量表中加载第四个 double 类型的值，并将其压入堆栈
  DMUL,  // 将堆栈顶的两个 double 类型的值相乘，并将结果压入堆栈
  DNEG,  // 将堆栈顶的 double 类型的值取反，并将结果压入堆栈
  DREM,  // 将堆栈顶的两个 double 类型的值取余，并将结果压入堆栈
  DRETURN,  // 将堆栈顶的 double 类型的值返回给调用者
  DSTORE,  // 将堆栈顶的 double 类型的值存入局部变量表的一个位置
  DSTORE_0,  // 将堆栈顶的 double 类型的值存入局本变量表的第一个位置
  DSTORE_1,  // 将堆栈顶的 double 类型的值存入局本变量表的第二个位置
  DSTORE_2,  // 将堆栈顶的 double 类型的值存入局本变量表的第三个位置
  DSTORE_3,  // 将堆栈顶的 double 类型的值存入局本变量表的第四个位置
  DSUB,  // 将堆栈顶的两个 double 类型的值相减，并将结果压入堆栈
  DUP,  // 将堆栈顶的 double 类型的值复制一份，并将复制的值压入堆栈
  DUP_X1,  // 将堆栈顶的 double
           // 类型的值复制一份，并将复制的值压入堆栈的第二个位置
  DUP_X2,  // 将堆栈顶的 double
           // 类型的值复制一份，并将复制的值压入堆栈的第三个位置
  DUP2,  // 将堆栈顶的两个 double 类型的值复制一份，并将复制的值压入堆栈
  DUP2_X1,  // 将堆栈顶的两个 double
            // 类型的值复制一份，并将复制的值压入堆栈的第二个位置
  DUP2_X2,  // 将堆栈顶的两个 double
            // 类型的值复制一份，并将复制的值压入堆栈的第三个位置
  F2D,  // 将 float 类型的数值转换为 double 类型的数值，并将其压入堆栈
  F2I,  // 将 float 类型的数值转换为 int
  F2L,  // 将 float 类型的数值转换为 long 类型的数值，并将其压入堆栈
  FADD,  // 将堆栈顶的两个 float 类型的值相加，并将结果压入堆栈
  FALOAD,  // 从 float 类型的数组中加载一个元素，并将其压入堆栈
  FASTORE,  // 将堆栈顶的 float 类型的值存入 float 类型的数组中
  FCMPG,  // 将堆栈顶的两个 float 类型的值进行大于比较，并将结果压入堆栈
  FCMPL,  // 将堆栈顶的两个 float 类型的值进行小于比较，并将结果压入堆栠
  FCONST_0,  // 将 float 类型的 0.0 压入堆栈
  FCONST_1,  // 将 float 类型的 1.0 压入堆栈
  FCONST_2,  // 将 float 类型的 2.0 压入堆栈
  FDIV,  // 将堆栈顶的两个 float 类型的值相除，并将结果压入堆栈
  FLOAD,  // 从局部变量表中加载一个 float 类型的值，并将其压入堆栈
  FLOAD_0,  // 从局本变量表中加载第一个 float 类型的值，并将其压入堆栈
  FLOAD_1,  // 从局本变量表中加载第二个 float 类型的值，并将其压入堆栈
  FLOAD_2,  // 从局本变量表中加载第三个 float 类型的值，并将其压入堆栈
  FLOAD_3,  // 从局本变量表中加载第四个 float 类型的值，并将其压入堆栈
  FMUL,  // 将堆栈顶的两个 float 类型的值相乘，并将结果压入堆栈
  FNEG,  // 将堆栈顶的 float 类型的值取反，并将结果压入堆栈
  FREM,  // 将堆栈顶的两个 float 类型的值取余，并将结果压入堆栈
  FRETURN,  // 将堆栈顶的 float 类型的值返回给调用者
  FSTORE,  // 将堆栈顶的 float 类型的值存入局部变量表的一个位置
  FSTORE_0,  // 将堆栈顶的 float 类型的值存入局本变量表的第一个位置
  FSTORE_1,  // 将堆栈顶的 float 类型的值存入局本变量表的第二个位置
  FSTORE_2,  // 将堆栈顶的 float 类型的值存入局本变量表的第三个位置
  FSTORE_3,  // 将堆栈顶的 float 类型的值存入局本变量表的第四个位置
  FSUB,  // 将堆栈顶的两个 float 类型的值相减，并将结果压入堆栈
  GETFIELD,   // 从对象的字段中获取值，并将其压入堆栈
  GETSTATIC,  // 从类的静态字段中获取值，并将其压入堆栈
  GOTO,       // 无条件地跳转到指定的字节码指令
  GOTO_W,     // 无条件地跳转到指定的字节码指令（宽字节码）
  I2B,  // 将 int 类型的值转换为 byte 类型的值，并将结果压入堆栈
  I2C,  // 将 int 类型的值转换为 char 类型的值，并将结果压入堆栈
  I2D,  // 将 int 类型的值转换为 double 类型的值，并将结果压入堆栈
  I2F,  // 将 int 类型的值转换为 float 类型的值，并将结果压入堆栈
  I2L,  // 将 int 类型的值转换为 long 类型的值，并将结果压入堆栈
  I2S,  // 将 int 类型的值转换为 short 类型的值，并将结果压入堆栈
  IADD,  // 将堆栈顶的两个 int 类型的值相加，并将结果压入堆栈
  IALOAD,  // 从 int 数组中获取指定索引的值，并将其压入堆栈
  IAND,  // 将堆栈顶的两个 int 类型的值按位与，并将结果压入堆栈
  IASTORE,    // 将堆栈顶的值存储到 int 数组指定索引的位置
  ICONST_M1,  // 将 int 类型的值 -1 压入堆栈
  ICONST_0,   // 将 int 类型的值 0 压入堆栈
  ICONST_1,   // 将 int 类型的值 1 压入堆栈
  ICONST_2,   // 将 int 类型的值 2 压入堆栈
  ICONST_3,   // 将 int 类型的值 3 压入堆栈
  ICONST_4,   // 将 int 类型的值 4 压入堆栈
  ICONST_5,   // 将 int 类型的值 5 压入堆栈
  IDIV,  // 将堆栈顶的两个 int 类型的值相除，并将结果压入堆栈
  IF_ACMPEQ,  // 如果堆栈顶的两个引用类型的值相等，则跳转到指定的字节码指令
  IF_ACMPNE,  // 如果堆栈顶的两个引用类型的值不相等，则跳转到指定的字节码指令
  IF_ICMPEQ,  // 如果堆栈顶的两个 int 类型的值相等，则跳转到指定的字节码指令
  IF_ICMPGE,  // 如果堆栈顶的两个 int 类型的值大于等于，则跳转到指定的字节码指令
  IF_ICMPGT,  // 如果堆栈顶的两个 int 类型的值大于，则跳转到指定的字节码指令
  IF_ICMPLE,  // 如果堆栈顶的两个 int 类型的值小于等于，则
  IF_ICMPLT,  // 如果堆栈顶的两个 int 类型的值小于，则跳转到指定的字节码指令
  IF_ICMPNE,  // 如果堆栈顶的两个 int 类型的值不相等，则跳转到指定的字节码指令
  IFEQ,  // 如果堆栈顶的 int 类型的值等于 0，则跳转到指定的字节码指令
  IFGE,  // 如果堆栈顶的 int 类型的值大于等于 0，则跳转到指定的字节码指令
  IFGT,  // 如果堆栈顶的 int 类型的值大于 0，则跳转到指定的字节码指令
  IFLE,  // 如果堆栈顶的 int 类型的值小于等于 0，则跳转到指定的字节码指令
  IFLT,  // 如果堆栈顶的 int 类型的值小于 0，则跳转到指定的字节码指令
  IFNE,  // 如果堆栈顶的 int 类型的值不等于 0，则跳转到指定的字节码指令
  IFNONNULL,  // 如果引用类型的值非空，则跳转到指定的字节码指令
  IFNULL,  // 如果引用类型的值为空，则跳转到指定的字节码指令
  IINC,     // 将 int 类型的变量增加指定值
  ILOAD,    // 将 int 类型的变量加载到堆栈
  ILOAD_0,  // 将 int 类型的变量加载到堆栈（索引为 0）
  ILOAD_1,  // 将 int 类型的变量加载到堆栈（索引为 1）
  ILOAD_2,  // 将 int 类型的变量加载到堆栈（索引为 2）
  ILOAD_3,  // 将 int 类型的变量加载到堆栈（索引为 3）
  IMPDEP1,  // 指令保留（第一类依赖项）
  IMPDEP2,  // 指令保留（第二类依赖项）
  IMUL,  // 将堆栈顶的两个 int 类型的值相乘，并将结果压入堆栈
  INEG,  // 将堆栈顶的 int 类型的值取反，并将结果压入堆栈
  INSTANCEOF,  // 判断对象是否为某个类的实例，并将结果压入堆栈
  INVOKEDYNAMIC,    // 动态调用方法
  INVOKEINTERFACE,  // 调用接口中的方法
  INVOKESPECIAL,    // 调用特定对象的方法
  INVOKESTATIC,     // 调用静态方法
  INVOKEVIRTUAL,    // 调用虚方法
  IOR,  // 将堆栈顶的两个 int 类型的值按位或，并将结果压入堆栈
  IREM,  // 将堆栈顶的两个 int 类型的值求余，并将结果压入堆栈
  IRETURN,  // 从方法中返回 int 类型的值
  ISHL,     // 将 int 类型的值左移指定位数，并将结果压入堆栈
  ISHR,  // 将 int 类型的值带符号右移指定位数，并将结果压入堆栈
  ISTORE,    // 将 int 类型的值存储到变量
  ISTORE_0,  // 将 int 类型的值存储到变量（索引为 0）
  ISTORE_1,  // 将 int 类型的值存储到变量（索引为 1）
  ISTORE_2,  // 将 int 类型的值存储到变量（索引为 2）
  ISTORE_3,  // 将 int 类型的值存储到变量（索引为 3）
  ISUB,  // 将堆栈顶的两个 int 类型的值相减，并将结果压入堆栈
  IUSHR,  // 将 int 类型的值无符号
  IXOR,  // 将堆栈顶的两个 long 类型的值按位异或，并将结果压入堆栈
  JSR,  // 将当前指令指针压入堆栈，并跳转到指定的字节码指令
  JSR_W,  // 与 JSR 相同，但可以跳转到更远的字节码指令
  L2D,  // 将 long 类型的值转换为 double 类型，并将结果压入堆栈
  L2F,  // 将 long 类型的值转换为 float 类型，并将结果压入堆栈
  L2I,  // 将 long 类型的值转换为 int 类型，并将结果压入堆栈
  LADD,  // 将堆栈顶的两个 long 类型的值相加，并将结果压入堆栈
  LALOAD,  // 将 long 类型的值从数组中加载，并将结果压入堆栈
  LAND,  // 将堆栈顶的两个 long 类型的值按位与，并将结果压入堆栈
  LASTORE,  // 将 long 类型的值存储到数组中
  LCMP,  // 比较堆栈顶的两个 long 类型的值的大小，并将结果压入堆栈
  LCONST_0,  // 将 long 类型的值 0 压入堆栈
  LCONST_1,  // 将 long 类型的值 1 压入堆栈
  LDC,       // 将 int 类型的常量值或字符串引用压入堆栈
  LDC_W,     // 与 LDC 相同，但可以压入更大的常量值
  LDC2_W,  // 与 LDC 相同，但可以压入更大的常量值（双倍宽度）
  LDIV,  // 将堆栈顶的两个 long 类型的值相除，并将结果压入堆栈
  LLOAD,    // 将 long 类型的值加载到堆栈
  LLOAD_0,  // 将 long 类型的值加载到堆栈（索引为 0）
  LLOAD_1,  // 将 long 类型的值加载到堆栈（索引为 1）
  LLOAD_2,  // 将 long 类型的值加载到堆栈（索引为 2）
  LLOAD_3,  // 将 long 类型的值加载到堆栈（索引为 3）
  LMUL,  // 将堆栈顶的两个 long 类型的值相乘，并将结果压入堆栈
  LNEG,  // 将堆栈顶的 long 类型的值取反，并将结果压入堆栈
  LOOKUPSWITCH,  // 根据堆栈顶的 long 类型的值，跳转到指定的字节码指令
  LOR,  // 将堆栈顶的两个 long 类型的值按位或，并将结果压入堆栈
  LREM,  // 将堆栈顶的两个 long 类型的值求余，并将结果压入堆栈
  LRETURN,  // 从方法中返回 long 类型的值
  LSHL,  // 将堆栈顶的 long 类型的值左移，并将结果压入堆栈
  LSHR,  // 将堆栈顶的 long 类型的值右移（有符号），并将结果压入堆栈
  LSTORE,    // 将 long 类型的值存储到本地变量表中
  LSTORE_0,  // 将 long 类型的值存储到本地变量表中（索引为 0）
  LSTORE_1,  // 将 long 类型的值存储到本地变量表中（索引为 1）
  LSTORE_2,  // 将 long 类型的值存储到本地变量表中（索引为 2）
  LSTORE_3,  // 将 long 类型的值存储到本地变量表中（索引为 3）
  LSUB,  // 将堆栈顶的两个 long 类型的值相减，并将结果压入堆栈
  LUSHR,  // 将堆栈顶的 long 类型的值右移（无符号），并将结果压入堆栈
  LXOR,  // 将堆栈顶的两个 long 类型的值按位异或，并将结果压入堆栈
  MONITORENTER,    // 进入对象的监视器（同步块）
  MONITOREXIT,     // 退出对象的监视器（同步块）
  MULTIANEWARRAY,  // 创建多维数组，并将引用值压入堆栈
  NEW,             // 创建一个实例并将引用值压入堆栈
  NEWARRAY,   // 创建一个基本类型数组，并将引用值压入堆栈
  NOP,        // 什么也不做
  POP,        // 弹出栈顶数值
  POP2,       // 弹出两个栈顶数值
  PUTFIELD,   // 将值存储到对象的字段中
  PUTSTATIC,  // 将值存储到类的静态字段中
  RET,        // 从方法返回
  RETURN,     // 从当前方法返回
  SALOAD,   // 从数组中加载 short 类型的值，并将结果压入堆栈
  SASTORE,  // 将 short 类型的值存储到数组中
  SIPUSH,   // 将 short 类型的常量值压入堆栈
  SWAP,     // 交换栈顶两个数值
  TABLESWITCH,  // 根据给定值跳转到指定的字节码指令
  WIDE          // 扩展指令（增加索引宽度）