Yes, it is as you guessed. The JVM/JRE uses Java bytecode as its instruction set and each JVM needs to be compiled on and be runnable on the native/local hardware (and therefore the local instruction set). This diagram from Wikipedia illustrates this well I think:

The JRE/JVM needs to be compiled for the specific hardware it runs on, though the Java bytecode definitions and interpretations by the JVM itself stay the same. As you point out, the Java bytecode can be seen as a kind of abstraction layer between the Java source code and the local machine/binary code. It does allow for a separation of concerns between the typical Java programmer and needing to know anything machine-specific, as almost all of that is handled by the JVM/JRE.

cafe babe 0000 0032 0022 0a00 0600 1409
0015 0016 0800 170a 0018 0019 0700 1a07
001b 0100 063c 696e 6974 3e01 0003 2829
5601 0004 436f 6465 0100 0f4c 696e 654e
756d 6265 7254 6162 6c65 0100 124c 6f63
616c 5661 7269 6162 6c65 5461 626c 6501
0004 7468 6973 0100 0c4c 4865 6c6c 6f57
6f72 6c64 3b01 0004 6d61 696e 0100 1628
5b4c 6a61 7661 2f6c 616e 672f 5374 7269
6e67 3b29 5601 0004 6172 6773 0100 135b
4c6a 6176 612f 6c61 6e67 2f53 7472 696e
673b 0100 0a53 6f75 7263 6546 696c 6501
000f 4865 6c6c 6f57 6f72 6c64 2e6a 6176
610c 0007 0008 0700 1c0c 001d 001e 0100
0b48 656c 6c6f 2c57 6f72 6c64 0700 1f0c
0020 0021 0100 0a48 656c 6c6f 576f 726c
6401 0010 6a61 7661 2f6c 616e 672f 4f62
6a65 6374 0100 106a 6176 612f 6c61 6e67
2f53 7973 7465 6d01 0003 6f75 7401 0015
4c6a 6176 612f 696f 2f50 7269 6e74 5374
7265 616d 3b01 0013 6a61 7661 2f69 6f2f
5072 696e 7453 7472 6561 6d01 0007 7072
696e 746c 6e01 0015 284c 6a61 7661 2f6c
616e 672f 5374 7269 6e67 3b29 5600 2100
0500 0600 0000 0000 0200 0100 0700 0800
0100 0900 0000 2f00 0100 0100 0000 052a
b700 01b1 0000 0002 000a 0000 0006 0001
0000 0007 000b 0000 000c 0001 0000 0005
000c 000d 0000 0009 000e 000f 0001 0009
0000 0037 0002 0001 0000 0009 b200 0212
03b6 0004 b100 0000 0200 0a00 0000 0a00
0200 0000 0900 0800 0a00 0b00 0000 0c00
0100 0000 0900 1000 1100 0000 0100 1200
0000 0200 13


$ javap -c HelloWorld.class 
Compiled from "HelloWorld.java"
public class HelloWorld {
  public HelloWorld();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3                  // String Hello,World
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
}

0×04
iconst_1
將int型1推送至棧頂

0×05
iconst_2
將int型2推送至棧頂

0×06
iconst_3
將int型3推送至棧頂

0×07
iconst_4
將int型4推送至棧頂

0×08
iconst_5
將int型5推送至棧頂

0×09
lconst_0
將long型0推送至棧頂

0x0a
lconst_1
將long型1推送至棧頂

0x0b
fconst_0
將float型0推送至棧頂

0x0c
fconst_1
將float型1推送至棧頂

0x0d
fconst_2
將float型2推送至棧頂

0x0e
dconst_0
將double型0推送至棧頂

0x0f
dconst_1
將double型1推送至棧頂

0×10
bipush
將單字節的常量值(-128~127)推送至棧頂

0×11
sipush
將一個短整型常量值(-32768~32767)推送至棧頂

0×12
ldc
將int, float或String型常量值從常量池中推送至棧頂

0×13
ldc_w
將int, float或String型常量值從常量池中推送至棧頂（寬索引）

0×14
ldc2_w
將long或double型常量值從常量池中推送至棧頂（寬索引）

0×15
iload
將指定的int型本地變量推送至棧頂

0×16
lload
將指定的long型本地變量推送至棧頂

0×17
fload
將指定的float型本地變量推送至棧頂

0×18
dload
將指定的double型本地變量推送至棧頂

0×19
aload
將指定的引用類型本地變量推送至棧頂

0x1a
iload_0
將第0個int型本地變量推送至棧頂

0x1b
iload_1
將第1個int型本地變量推送至棧頂

0x1c
iload_2
將第2個int型本地變量推送至棧頂

0x1d
iload_3
將第3個int型本地變量推送至棧頂

0x1e
lload_0
將第0個long型本地變量推送至棧頂

0x1f
lload_1
將第1個long型本地變量推送至棧頂

0×20
lload_2
將第2個long型本地變量推送至棧頂

0×21
lload_3
將第3個long型本地變量推送至棧頂

0×22
fload_0
將第0個float型本地變量推送至棧頂

0×23
fload_1
將第1個float型本地變量推送至棧頂

0×24
fload_2
將第2個float型本地變量推送至棧頂

0×25
fload_3
將第3個float型本地變量推送至棧頂

0×26
dload_0
將第0個double型本地變量推送至棧頂

0×27
dload_1
將第1個double型本地變量推送至棧頂

0×28
dload_2
將第2個double型本地變量推送至棧頂

0×29
dload_3
將第3個double型本地變量推送至棧頂

0x2a
aload_0
將第0個引用類型本地變量推送至棧頂

0x2b
aload_1
將第1個引用類型本地變量推送至棧頂

0x2c
aload_2
將第2個引用類型本地變量推送至棧頂

0x2d
aload_3
將第3個引用類型本地變量推送至棧頂

0x2e
iaload
將int型數組指定索引的值推送至棧頂

0x2f
laload
將long型數組指定索引的值推送至棧頂

0×30
faload
將float型數組指定索引的值推送至棧頂

0×31
daload
將double型數組指定索引的值推送至棧頂

0×32
aaload
將引用型數組指定索引的值推送至棧頂

0×33
baload
將boolean或byte型數組指定索引的值推送至棧頂

0×34
caload
將char型數組指定索引的值推送至棧頂

0×35
saload
將short型數組指定索引的值推送至棧頂

0×36
istore
將棧頂int型數值存入指定本地變量

0×37
lstore
將棧頂long型數值存入指定本地變量

0×38
fstore
將棧頂float型數值存入指定本地變量

0×39
dstore
將棧頂double型數值存入指定本地變量

0x3a
astore
將棧頂引用型數值存入指定本地變量

0x3b
istore_0
將棧頂int型數值存入第0個本地變量

0x3c
istore_1
將棧頂int型數值存入第1個本地變量

0x3d
istore_2
將棧頂int型數值存入第2個本地變量

0x3e
istore_3
將棧頂int型數值存入第3個本地變量

0x3f
lstore_0
將棧頂long型數值存入第0個本地變量

0×40
lstore_1
將棧頂long型數值存入第1個本地變量

0×41
lstore_2
將棧頂long型數值存入第2個本地變量

0×42
lstore_3
將棧頂long型數值存入第3個本地變量

0×43
fstore_0
將棧頂float型數值存入第0個本地變量

0×44
fstore_1
將棧頂float型數值存入第1個本地變量

0×45
fstore_2
將棧頂float型數值存入第2個本地變量

0×46
fstore_3
將棧頂float型數值存入第3個本地變量

0×47
dstore_0
將棧頂double型數值存入第0個本地變量

0×48
dstore_1
將棧頂double型數值存入第1個本地變量

0×49
dstore_2
將棧頂double型數值存入第2個本地變量

0x4a
dstore_3
將棧頂double型數值存入第3個本地變量

0x4b
astore_0
將棧頂引用型數值存入第0個本地變量

0x4c
astore_1
將棧頂引用型數值存入第1個本地變量

0x4d
astore_2
將棧頂引用型數值存入第2個本地變量

0x4e
astore_3
將棧頂引用型數值存入第3個本地變量

0x4f
iastore
將棧頂int型數值存入指定數組的指定索引位置

0×50
lastore
將棧頂long型數值存入指定數組的指定索引位置

0×51
fastore
將棧頂float型數值存入指定數組的指定索引位置

0×52
dastore
將棧頂double型數值存入指定數組的指定索引位置

0×53
aastore
將棧頂引用型數值存入指定數組的指定索引位置

0×54
bastore
將棧頂boolean或byte型數值存入指定數組的指定索引位置

0×55
castore
將棧頂char型數值存入指定數組的指定索引位置

0×56
sastore
將棧頂short型數值存入指定數組的指定索引位置

0×57
pop
將棧頂數值彈出 (數值不能是long或double類型的)

0×58
pop2
將棧頂的一個（long或double類型的)或兩個數值彈出（其它）

0×59
dup
復制棧頂數值并將復制值壓入棧頂

0x5a
dup_x1
復制棧頂數值并將兩個復制值壓入棧頂

0x5b
dup_x2
復制棧頂數值并將三個（或兩個）復制值壓入棧頂

0x5c
dup2
復制棧頂一個（long或double類型的)或兩個（其它）數值并將復制值壓入棧頂

0x5d
dup2_x1
<待補充>

0x5e
dup2_x2
<待補充>

0x5f
swap
將棧最頂端的兩個數值互換(數值不能是long或double類型的)

0×60
iadd
將棧頂兩int型數值相加并將結果壓入棧頂

0×61
ladd
將棧頂兩long型數值相加并將結果壓入棧頂

0×62
fadd
將棧頂兩float型數值相加并將結果壓入棧頂

0×63
dadd
將棧頂兩double型數值相加并將結果壓入棧頂

0×64
isub
將棧頂兩int型數值相減并將結果壓入棧頂

0×65
lsub
將棧頂兩long型數值相減并將結果壓入棧頂

0×66
fsub
將棧頂兩float型數值相減并將結果壓入棧頂

0×67
dsub
將棧頂兩double型數值相減并將結果壓入棧頂

0×68
imul
將棧頂兩int型數值相乘并將結果壓入棧頂

0×69
lmul
將棧頂兩long型數值相乘并將結果壓入棧頂

0x6a
fmul
將棧頂兩float型數值相乘并將結果壓入棧頂

0x6b
dmul
將棧頂兩double型數值相乘并將結果壓入棧頂

0x6c
idiv
將棧頂兩int型數值相除并將結果壓入棧頂

0x6d
ldiv
將棧頂兩long型數值相除并將結果壓入棧頂

0x6e
fdiv
將棧頂兩float型數值相除并將結果壓入棧頂

0x6f
ddiv
將棧頂兩double型數值相除并將結果壓入棧頂

0×70
irem
將棧頂兩int型數值作取模運算并將結果壓入棧頂

0×71
lrem
將棧頂兩long型數值作取模運算并將結果壓入棧頂

0×72
frem
將棧頂兩float型數值作取模運算并將結果壓入棧頂

0×73
drem
將棧頂兩double型數值作取模運算并將結果壓入棧頂

0×74
ineg
將棧頂int型數值取負并將結果壓入棧頂

0×75
lneg
將棧頂long型數值取負并將結果壓入棧頂

0×76
fneg
將棧頂float型數值取負并將結果壓入棧頂

0×77
dneg
將棧頂double型數值取負并將結果壓入棧頂

0×78
ishl
將int型數值左移位指定位數并將結果壓入棧頂

0×79
lshl
將long型數值左移位指定位數并將結果壓入棧頂

0x7a
ishr
將int型數值右（符號）移位指定位數并將結果壓入棧頂

0x7b
lshr
將long型數值右（符號）移位指定位數并將結果壓入棧頂

0x7c
iushr
將int型數值右（無符號）移位指定位數并將結果壓入棧頂

0x7d
lushr
將long型數值右（無符號）移位指定位數并將結果壓入棧頂

0x7e
iand
將棧頂兩int型數值作“按位與”并將結果壓入棧頂

0x7f
land
將棧頂兩long型數值作“按位與”并將結果壓入棧頂

0×80
ior
將棧頂兩int型數值作“按位或”并將結果壓入棧頂

0×81
lor
將棧頂兩long型數值作“按位或”并將結果壓入棧頂

0×82
ixor
將棧頂兩int型數值作“按位異或”并將結果壓入棧頂

0×83
lxor
將棧頂兩long型數值作“按位異或”并將結果壓入棧頂

0×84
iinc
將指定int型變量增加指定值，可以有兩個變量，分別表示index, const，index指第index個int型本地變量，const增加的值

0×85
i2l
將棧頂int型數值強制轉換成long型數值并將結果壓入棧頂

0×86
i2f
將棧頂int型數值強制轉換成float型數值并將結果壓入棧頂

0×87
i2d
將棧頂int型數值強制轉換成double型數值并將結果壓入棧頂

0×88
l2i
將棧頂long型數值強制轉換成int型數值并將結果壓入棧頂

0×89
l2f
將棧頂long型數值強制轉換成float型數值并將結果壓入棧頂

0x8a
l2d
將棧頂long型數值強制轉換成double型數值并將結果壓入棧頂

0x8b
f2i
將棧頂float型數值強制轉換成int型數值并將結果壓入棧頂

0x8c
f2l
將棧頂float型數值強制轉換成long型數值并將結果壓入棧頂

0x8d
f2d
將棧頂float型數值強制轉換成double型數值并將結果壓入棧頂

0x8e
d2i
將棧頂double型數值強制轉換成int型數值并將結果壓入棧頂

0x8f
d2l
將棧頂double型數值強制轉換成long型數值并將結果壓入棧頂

0×90
d2f
將棧頂double型數值強制轉換成float型數值并將結果壓入棧頂

0×91
i2b
將棧頂int型數值強制轉換成byte型數值并將結果壓入棧頂

0×92
i2c
將棧頂int型數值強制轉換成char型數值并將結果壓入棧頂

0×93
i2s
將棧頂int型數值強制轉換成short型數值并將結果壓入棧頂

0×94
lcmp
比較棧頂兩long型數值大小，并將結果（1，0，-1）壓入棧頂

0×95
fcmpl
比較棧頂兩float型數值大小，并將結果（1，0，-1）壓入棧頂；當其中一個數值為NaN時，將-1壓入棧頂

0×96
fcmpg
比較棧頂兩float型數值大小，并將結果（1，0，-1）壓入棧頂；當其中一個數值為NaN時，將1壓入棧頂

0×97
dcmpl
比較棧頂兩double型數值大小，并將結果（1，0，-1）壓入棧頂；當其中一個數值為NaN時，將-1壓入棧頂

0×98
dcmpg
比較棧頂兩double型數值大小，并將結果（1，0，-1）壓入棧頂；當其中一個數值為NaN時，將1壓入棧頂

0×99
ifeq
當棧頂int型數值等于0時跳轉

0x9a
ifne
當棧頂int型數值不等于0時跳轉

0x9b
iflt
當棧頂int型數值小于0時跳轉

0x9c
ifge
當棧頂int型數值大于等于0時跳轉

0x9d
ifgt
當棧頂int型數值大于0時跳轉

0x9e
ifle
當棧頂int型數值小于等于0時跳轉

0x9f
if_icmpeq
比較棧頂兩int型數值大小，當結果等于0時跳轉

0xa0
if_icmpne
比較棧頂兩int型數值大小，當結果不等于0時跳轉

0xa1
if_icmplt
比較棧頂兩int型數值大小，當結果小于0時跳轉

0xa2
if_icmpge
比較棧頂兩int型數值大小，當結果大于等于0時跳轉

0xa3
if_icmpgt
比較棧頂兩int型數值大小，當結果大于0時跳轉

0xa4
if_icmple
比較棧頂兩int型數值大小，當結果小于等于0時跳轉

0xa5
if_acmpeq
比較棧頂兩引用型數值，當結果相等時跳轉

0xa6
if_acmpne
比較棧頂兩引用型數值，當結果不相等時跳轉

0xa7
goto
無條件跳轉

0xa8
jsr
跳轉至指定16位offset位置，并將jsr下一條指令地址壓入棧頂

0xa9
ret
返回至本地變量指定的index的指令位置（一般與jsr, jsr_w聯合使用）

0xaa
tableswitch
用于switch條件跳轉，case值連續（可變長度指令）

0xab
lookupswitch
用于switch條件跳轉，case值不連續（可變長度指令）

0xac
ireturn
從當前方法返回int

0xad
lreturn
從當前方法返回long

0xae
freturn
從當前方法返回float

0xaf
dreturn
從當前方法返回double

0xb0
areturn
從當前方法返回對象引用

0xb1
return
從當前方法返回void

0xb2
getstatic
獲取指定類的靜態域，并將其值壓入棧頂

0xb3
putstatic
為指定的類的靜態域賦值

0xb4
getfield
獲取指定類的實例域，并將其值壓入棧頂

0xb5
putfield
為指定的類的實例域賦值

0xb6
invokevirtual
調用實例方法

0xb7
invokespecial
調用超類構造方法，實例初始化方法，私有方法

0xb8
invokestatic
調用靜態方法

0xb9
invokeinterface
調用接口方法

0xba
–

0xbb
new
創建一個對象，并將其引用值壓入棧頂

0xbc
newarray
創建一個指定原始類型（如int, float, char…）的數組，并將其引用值壓入棧頂

0xbd
anewarray
創建一個引用型（如類，接口，數組）的數組，并將其引用值壓入棧頂

0xbe
arraylength
獲得數組的長度值并壓入棧頂

0xbf
athrow
將棧頂的異常拋出

0xc0
checkcast
檢驗類型轉換，檢驗未通過將拋出ClassCastException

0xc1
instanceof
檢驗對象是否是指定的類的實例，如果是將1壓入棧頂，否則將0壓入棧頂

0xc2
monitorenter
獲得對象的鎖，用于同步方法或同步塊

0xc3
monitorexit
釋放對象的鎖，用于同步方法或同步塊

0xc4
wide
當本地變量的索引超過255時使用該指令擴展索引寬度。

0xc5
multianewarray
create a new array of dimensions dimensions with elements of type identified by class reference in constant pool index (indexbyte1 << 8 + indexbyte2); the sizes of each dimension is identified by count1, [count2, etc.]

0xc6
ifnull
if value is null, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)

0xc7
ifnonnull
if value is not null, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)

0xc8
goto_w
goes to another instruction at branchoffset (signed int constructed from unsigned bytes branchbyte1 << 24 + branchbyte2 << 16 + branchbyte3 << 8 + branchbyte4)

0xc9
jsr_w
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

0xca
breakpoint
reserved for breakpoints in Java debuggers; should not appear in any class file

0xcb-0xfd
未命名
these values are currently unassigned for opcodes and are reserved for future use

0xfe
impdep1
reserved for implementation-dependent operations within debuggers; should not appear in any class file

0xff
impdep2
reserved for implementation-dependent operations within debuggers; should not appear in any class file

有了以上指令集表，那么在查看字節碼就方便多了。
對應英文 => https://en.wikipedia.org/wiki/Java_bytecode_instruction_listings

來幾個sample:

public void sample1(){
int num = 5;
}

javap -c 查看字節碼

public void sample1();
Code:
0: iconst_5
1: istore_1
2: return

解釋

iconst_5 //將int型5推送至棧頂
istore_1 //將棧頂int型數值存入第1個本地變量
return //從當前方法返回void

public int sample2(int a, int b) {
return a + b;
}

字節碼及解釋

public int sample2(int, int);
Code:
0: iload_1 //將第1個int型本地變量推送至棧頂
1: iload_2 //將第2個int型本地變量推送至棧頂
2: iadd //將棧頂兩int型數值相加并將結果壓入棧頂
3: ireturn //從當前方法返回int

稍稍復雜點

public float sample3() {
float num = 0;
for (int i = 0; i < 5; i++) {
num *= i;
}
return num;
}

字節碼及解釋

public float sample3();
Code:
0: fconst_0 //將float型0推送至棧頂
1: fstore_1 //將棧頂float型數值存入第1個本地變量
2: iconst_0 //將int型0推送至棧頂，也就是for循環中的i = 0
3: istore_2 //將棧頂int型數值存入第2個本地變量
4: iload_2 //將第2個int型本地變量推送至棧頂
5: iconst_5 //將int型5推送至棧頂，也就是for循環中的 最大值5
6: if_icmpge 20 //比較棧頂兩int型數值大小，當結果大于等于0時跳轉，
//也就是比較0是否大于等于5，(cpmge指compare larger equals)，如果是跳轉到到第20條指令
9: fload_1 //將第1個float型本地變量推送至棧頂，也就是變量num
10: iload_2 //將第2個int型本地變量推送至棧頂，也就是for循環中的變量i
11: i2f //int型強轉為float型，也就是把變量i強轉成float
12: fmul //將棧頂兩float型數值相乘并將結果壓入棧頂，也就是i與num相乘
13: fstore_1 //將棧頂float型數值存入第1個本地變量，也就是之前i與num的乘積
14: iinc 2, 1 //將指定int型變量增加指定值，將第2個int型本地變量增加1，
//可以看到，第2個int型本地變量就是之前的變量i
17: goto 4 //無條件跳轉到指令4，實現循環效果
20: fload_1 //將第1個float型本地變量推送至棧頂
21: freturn //從當前方法返回float

文章參考：

Java_bytecode_instruction_listings:

https://en.wikipedia.org/wiki/Java_bytecode_instruction_listings

JVM Opcode Reference:
http://homepages.inf.ed.ac.uk/kwxm/JVM/

jvm_instruction_set:

http://www.mobilefish.com/tutorials/java/java_quickguide_jvm_instruction_set.html

比如說，在多線程編程中，獲得一個對象的鎖，我們使用jvm指令集(jvm instruction set)中的monitorenter, monitorexit指令

Description: lock object for synchronized execution
Stack

Before  After
object to be locked       
Example

Jasm-------------------
aload_1      ; push object in local var 1
monitorenter      ; acquire lock on object
( do stuff to object )      ;
monitorexit      ; release lock
     ;
Exceptions

NullPointerException if object is null

問題1

那monitorenter, monitorexit指令最后經過jvm執行引擎，變成對應cpu機器的指令是什么？

問題2

最后編譯成匯編01字節碼，在OS&硬件層次上又是怎樣實現鎖對象的呢？

指令碼 助記符    說明
0x00 nop        無操作
0x01 aconst_null 將null推送至棧頂
0x02 iconst_m1    將int型-1推送至棧頂
0x03 iconst_0    將int型0推送至棧頂
0x04 iconst_1    將int型1推送至棧頂
0x05 iconst_2    將int型2推送至棧頂
0x06 iconst_3    將int型3推送至棧頂
0x07 iconst_4    將int型4推送至棧頂
0x08 iconst_5    將int型5推送至棧頂
0x09 lconst_0    將long型0推送至棧頂
0x0a lconst_1    將long型1推送至棧頂
0x0b fconst_0    將float型0推送至棧頂
0x0c fconst_1    將float型1推送至棧頂
0x0d fconst_2    將float型2推送至棧頂
0x0e dconst_0    將double型0推送至棧頂
0x0f dconst_1    將double型1推送至棧頂
0x10 bipush    將單字節的常量值(-128~127)推送至棧頂
0x11 sipush    將一個短整型常量值(-32768~32767)推送至棧頂
0x12 ldc    將int, float或String型常量值從常量池中推送至棧頂
0x13 ldc_w    將int, float或String型常量值從常量池中推送至棧頂（寬索引）
0x14 ldc2_w    將long或double型常量值從常量池中推送至棧頂（寬索引）
0x15 iload    將指定的int型本地變量推送至棧頂
0x16 lload    將指定的long型本地變量推送至棧頂
0x17 fload    將指定的float型本地變量推送至棧頂
0x18 dload    將指定的double型本地變量推送至棧頂
0x19 aload    將指定的引用類型本地變量推送至棧頂
0x1a iload_0    將第一個int型本地變量推送至棧頂
0x1b iload_1    將第二個int型本地變量推送至棧頂
0x1c iload_2    將第三個int型本地變量推送至棧頂
0x1d iload_3    將第四個int型本地變量推送至棧頂
0x1e lload_0    將第一個long型本地變量推送至棧頂
0x1f lload_1    將第二個long型本地變量推送至棧頂
0x20 lload_2    將第三個long型本地變量推送至棧頂
0x21 lload_3    將第四個long型本地變量推送至棧頂
0x22 fload_0    將第一個float型本地變量推送至棧頂
0x23 fload_1    將第二個float型本地變量推送至棧頂
0x24 fload_2    將第三個float型本地變量推送至棧頂
0x25 fload_3    將第四個float型本地變量推送至棧頂
0x26 dload_0    將第一個double型本地變量推送至棧頂
0x27 dload_1    將第二個double型本地變量推送至棧頂
0x28 dload_2    將第三個double型本地變量推送至棧頂
0x29 dload_3    將第四個double型本地變量推送至棧頂
0x2a aload_0    將第一個引用類型本地變量推送至棧頂
0x2b aload_1    將第二個引用類型本地變量推送至棧頂
0x2c aload_2    將第三個引用類型本地變量推送至棧頂
0x2d aload_3    將第四個引用類型本地變量推送至棧頂
0x2e iaload    將int型數組指定索引的值推送至棧頂
0x2f laload    將long型數組指定索引的值推送至棧頂
0x30 faload    將float型數組指定索引的值推送至棧頂
0x31 daload    將double型數組指定索引的值推送至棧頂
0x32 aaload    將引用型數組指定索引的值推送至棧頂
0x33 baload    將boolean或byte型數組指定索引的值推送至棧頂
0x34 caload    將char型數組指定索引的值推送至棧頂
0x35 saload    將short型數組指定索引的值推送至棧頂
0x36 istore    將棧頂int型數值存入指定本地變量
0x37 lstore    將棧頂long型數值存入指定本地變量
0x38 fstore    將棧頂float型數值存入指定本地變量
0x39 dstore    將棧頂double型數值存入指定本地變量
0x3a astore    將棧頂引用型數值存入指定本地變量
0x3b istore_0    將棧頂int型數值存入第一個本地變量
0x3c istore_1    將棧頂int型數值存入第二個本地變量
0x3d istore_2    將棧頂int型數值存入第三個本地變量
0x3e istore_3    將棧頂int型數值存入第四個本地變量
0x3f lstore_0    將棧頂long型數值存入第一個本地變量
0x40 lstore_1    將棧頂long型數值存入第二個本地變量
0x41 lstore_2    將棧頂long型數值存入第三個本地變量
0x42 lstore_3    將棧頂long型數值存入第四個本地變量
0x43 fstore_0    將棧頂float型數值存入第一個本地變量
0x44 fstore_1    將棧頂float型數值存入第二個本地變量
0x45 fstore_2    將棧頂float型數值存入第三個本地變量
0x46 fstore_3    將棧頂float型數值存入第四個本地變量
0x47 dstore_0    將棧頂double型數值存入第一個本地變量
0x48 dstore_1    將棧頂double型數值存入第二個本地變量
0x49 dstore_2    將棧頂double型數值存入第三個本地變量
0x4a dstore_3    將棧頂double型數值存入第四個本地變量
0x4b astore_0    將棧頂引用型數值存入第一個本地變量
0x4c astore_1    將棧頂引用型數值存入第二個本地變量
0x4d astore_2    將棧頂引用型數值存入第三個本地變量
0x4e astore_3    將棧頂引用型數值存入第四個本地變量
0x4f iastore    將棧頂int型數值存入指定數組的指定索引位置
0x50 lastore    將棧頂long型數值存入指定數組的指定索引位置
0x51 fastore    將棧頂float型數值存入指定數組的指定索引位置
0x52 dastore    將棧頂double型數值存入指定數組的指定索引位置
0x53 aastore    將棧頂引用型數值存入指定數組的指定索引位置
0x54 bastore    將棧頂boolean或byte型數值存入指定數組的指定索引位置
0x55 castore    將棧頂char型數值存入指定數組的指定索引位置
0x56 sastore    將棧頂short型數值存入指定數組的指定索引位置
0x57 pop     將棧頂數值彈出 (數值不能是long或double類型的)
0x58 pop2    將棧頂的一個（long或double類型的)或兩個數值彈出（其它）
0x59 dup     復制棧頂數值并將復制值壓入棧頂
0x5a dup_x1    復制棧頂數值并將兩個復制值壓入棧頂
0x5b dup_x2    復制棧頂數值并將三個（或兩個）復制值壓入棧頂
0x5c dup2    復制棧頂一個（long或double類型的)或兩個（其它）數值并將復制值壓入棧頂
0x5d dup2_x1    <待補充>
0x5e dup2_x2    <待補充>
0x5f swap    將棧最頂端的兩個數值互換(數值不能是long或double類型的)
0x60 iadd    將棧頂兩int型數值相加并將結果壓入棧頂
0x61 ladd    將棧頂兩long型數值相加并將結果壓入棧頂
0x62 fadd    將棧頂兩float型數值相加并將結果壓入棧頂
0x63 dadd    將棧頂兩double型數值相加并將結果壓入棧頂
0x64 isub    將棧頂兩int型數值相減并將結果壓入棧頂
0x65 lsub    將棧頂兩long型數值相減并將結果壓入棧頂
0x66 fsub    將棧頂兩float型數值相減并將結果壓入棧頂
0x67 dsub    將棧頂兩double型數值相減并將結果壓入棧頂
0x68 imul    將棧頂兩int型數值相乘并將結果壓入棧頂
0x69 lmul    將棧頂兩long型數值相乘并將結果壓入棧頂
0x6a fmul    將棧頂兩float型數值相乘并將結果壓入棧頂
0x6b dmul    將棧頂兩double型數值相乘并將結果壓入棧頂
0x6c idiv    將棧頂兩int型數值相除并將結果壓入棧頂
0x6d ldiv    將棧頂兩long型數值相除并將結果壓入棧頂
0x6e fdiv    將棧頂兩float型數值相除并將結果壓入棧頂
0x6f ddiv    將棧頂兩double型數值相除并將結果壓入棧頂
0x70 irem    將棧頂兩int型數值作取模運算并將結果壓入棧頂
0x71 lrem    將棧頂兩long型數值作取模運算并將結果壓入棧頂
0x72 frem    將棧頂兩float型數值作取模運算并將結果壓入棧頂
0x73 drem    將棧頂兩double型數值作取模運算并將結果壓入棧頂
0x74 ineg    將棧頂int型數值取負并將結果壓入棧頂
0x75 lneg    將棧頂long型數值取負并將結果壓入棧頂
0x76 fneg    將棧頂float型數值取負并將結果壓入棧頂
0x77 dneg    將棧頂double型數值取負并將結果壓入棧頂
0x78 ishl    將int型數值左移位指定位數并將結果壓入棧頂
0x79 lshl    將long型數值左移位指定位數并將結果壓入棧頂
0x7a ishr    將int型數值右（符號）移位指定位數并將結果壓入棧頂
0x7b lshr    將long型數值右（符號）移位指定位數并將結果壓入棧頂
0x7c iushr    將int型數值右（無符號）移位指定位數并將結果壓入棧頂
0x7d lushr    將long型數值右（無符號）移位指定位數并將結果壓入棧頂
0x7e iand    將棧頂兩int型數值作“按位與”并將結果壓入棧頂
0x7f land    將棧頂兩long型數值作“按位與”并將結果壓入棧頂
0x80 ior     將棧頂兩int型數值作“按位或”并將結果壓入棧頂
0x81 lor     將棧頂兩long型數值作“按位或”并將結果壓入棧頂
0x82 ixor    將棧頂兩int型數值作“按位異或”并將結果壓入棧頂
0x83 lxor    將棧頂兩long型數值作“按位異或”并將結果壓入棧頂
0x84 iinc    將指定int型變量增加指定值（i++, i--, i+=2）
0x85 i2l     將棧頂int型數值強制轉換成long型數值并將結果壓入棧頂
0x86 i2f     將棧頂int型數值強制轉換成float型數值并將結果壓入棧頂
0x87 i2d     將棧頂int型數值強制轉換成double型數值并將結果壓入棧頂
0x88 l2i     將棧頂long型數值強制轉換成int型數值并將結果壓入棧頂
0x89 l2f     將棧頂long型數值強制轉換成float型數值并將結果壓入棧頂
0x8a l2d     將棧頂long型數值強制轉換成double型數值并將結果壓入棧頂
0x8b f2i     將棧頂float型數值強制轉換成int型數值并將結果壓入棧頂
0x8c f2l     將棧頂float型數值強制轉換成long型數值并將結果壓入棧頂
0x8d f2d     將棧頂float型數值強制轉換成double型數值并將結果壓入棧頂
0x8e d2i     將棧頂double型數值強制轉換成int型數值并將結果壓入棧頂
0x8f d2l     將棧頂double型數值強制轉換成long型數值并將結果壓入棧頂
0x90 d2f     將棧頂double型數值強制轉換成float型數值并將結果壓入棧頂
0x91 i2b     將棧頂int型數值強制轉換成byte型數值并將結果壓入棧頂
0x92 i2c     將棧頂int型數值強制轉換成char型數值并將結果壓入棧頂
0x93 i2s     將棧頂int型數值強制轉換成short型數值并將結果壓入棧頂
0x94 lcmp    比較棧頂兩long型數值大小，并將結果（1，0，-1）壓入棧頂
0x95 fcmpl    比較棧頂兩float型數值大小，并將結果（1，0，-1）壓入棧頂；當其中一個數值為NaN時，將-1壓入棧頂
0x96 fcmpg    比較棧頂兩float型數值大小，并將結果（1，0，-1）壓入棧頂；當其中一個數值為NaN時，將1壓入棧頂
0x97 dcmpl    比較棧頂兩double型數值大小，并將結果（1，0，-1）壓入棧頂；當其中一個數值為NaN時，將-1壓入棧頂
0x98 dcmpg    比較棧頂兩double型數值大小，并將結果（1，0，-1）壓入棧頂；當其中一個數值為NaN時，將1壓入棧頂
0x99 ifeq    當棧頂int型數值等于0時跳轉
0x9a ifne    當棧頂int型數值不等于0時跳轉
0x9b iflt    當棧頂int型數值小于0時跳轉
0x9c ifge    當棧頂int型數值大于等于0時跳轉
0x9d ifgt    當棧頂int型數值大于0時跳轉
0x9e ifle    當棧頂int型數值小于等于0時跳轉
0x9f if_icmpeq    比較棧頂兩int型數值大小，當結果等于0時跳轉
0xa0 if_icmpne    比較棧頂兩int型數值大小，當結果不等于0時跳轉
0xa1 if_icmplt    比較棧頂兩int型數值大小，當結果小于0時跳轉
0xa2 if_icmpge    比較棧頂兩int型數值大小，當結果大于等于0時跳轉
0xa3 if_icmpgt    比較棧頂兩int型數值大小，當結果大于0時跳轉
0xa4 if_icmple    比較棧頂兩int型數值大小，當結果小于等于0時跳轉
0xa5 if_acmpeq    比較棧頂兩引用型數值，當結果相等時跳轉
0xa6 if_acmpne    比較棧頂兩引用型數值，當結果不相等時跳轉
0xa7 goto    無條件跳轉
0xa8 jsr     跳轉至指定16位offset位置，并將jsr下一條指令地址壓入棧頂
0xa9 ret     返回至本地變量指定的index的指令位置（一般與jsr, jsr_w聯合使用）
0xaa tableswitch    用于switch條件跳轉，case值連續（可變長度指令）
0xab lookupswitch    用于switch條件跳轉，case值不連續（可變長度指令）
0xac ireturn    從當前方法返回int
0xad lreturn    從當前方法返回long
0xae freturn    從當前方法返回float
0xaf dreturn    從當前方法返回double
0xb0 areturn    從當前方法返回對象引用
0xb1 return    從當前方法返回void
0xb2 getstatic    獲取指定類的靜態域，并將其值壓入棧頂
0xb3 putstatic    為指定的類的靜態域賦值
0xb4 getfield    獲取指定類的實例域，并將其值壓入棧頂
0xb5 putfield    為指定的類的實例域賦值
0xb6 invokevirtual    調用實例方法
0xb7 invokespecial    調用超類構造方法，實例初始化方法，私有方法
0xb8 invokestatic    調用靜態方法
0xb9 invokeinterface 調用接口方法
0xba --
0xbb new     創建一個對象，并將其引用值壓入棧頂
0xbc newarray    創建一個指定原始類型（如int, float, char…）的數組，并將其引用值壓入棧頂
0xbd anewarray    創建一個引用型（如類，接口，數組）的數組，并將其引用值壓入棧頂
0xbe arraylength 獲得數組的長度值并壓入棧頂
0xbf athrow    將棧頂的異常拋出
0xc0 checkcast    檢驗類型轉換，檢驗未通過將拋出ClassCastException
0xc1 instanceof 檢驗對象是否是指定的類的實例，如果是將1壓入棧頂，否則將0壓入棧頂
0xc2 monitorenter    獲得對象的鎖，用于同步方法或同步塊
0xc3 monitorexit    釋放對象的鎖，用于同步方法或同步塊
0xc4 wide    <待補充>
0xc5 multianewarray 創建指定類型和指定維度的多維數組（執行該指令時，操作棧中必須包含各維度的長度值），并將其引用值壓入棧頂
0xc6 ifnull    為null時跳轉
0xc7 ifnonnull    不為null時跳轉
0xc8 goto_w    無條件跳轉
0xc9 jsr_w    跳轉至指定32位offset位置，并將jsr_w下一條指令地址壓入棧頂