Java byte code 的学习意义

为啥要学java bytecode，这就跟你问我已经会python了为啥要学汇编一个道理。
我为啥要整理这些难记的知识 ？ 因为公司用到了某为的一个据说极其牛逼的技术框架，但是某为不给源码，导致理解总是肤浅的。

要了解应用，唯有剥开拆散了研究一番，于是JD就上了，但是还是有些代码反编译不出来，这时候 javap 就有用了，从指令级回推代码。

先转一份IBM牛人的笔记： http://it.deepinmind.com

Java字节码浅析（—）
英文原文链接，译文链接，原文作者：James Bloom，译者：有孚
明白Java代码是如何编译成字节码并在JVM上运行的非常重要，这有助于理解程序运行的时候究竟发生了些什么。理解这点不仅能搞清语言特性是如何实现的，并且在做方案讨论的时候能清楚相应的副作用及权衡利弊。
本文介绍了Java代码是如何编译成字节码并在JVM上执行的。想了解JVM的内部结构以及字节码运行时用到的各个内存区域，可以看下我前面的一篇关于JVM内部细节的文章。
本文分为三部分，每一部分都分成几个小节。每个小节都可以单独阅读，不过由于一些概念是逐步建立起来的，如果你依次阅读完所有章节会更简单一些。每一节都会覆盖到Java代码中的不同结构，并详细介绍了它们是如何编译并执行的。

1. 第一部分， 基础概念
   变量
   局部变量
   JVM是一个基于栈的架构。方法执行的时候（包括main方法），在栈上会分配一个新的帧，这个栈帧包含一组局部变量。这组局部变量包含了方法运行过程中用到的所有变量，包括this引用，所有的方法参数，以及其它局部定义的变量。对于类方法（也就是static方法）来说，方法参数是从第0个位置开始的，而对于实例方法来说，第0个位置上的变量是this指针。
   局部变量可以是以下这些类型：

• char
• long
• short
• int
• float
• double
• 引用
• 返回地址
  除了long和double类型外，每个变量都只占局部变量区中的一个变量槽(slot)，而long及double会占用两个连续的变量槽，因为这些类型是64位的。
  当一个新的变量创建的时候，操作数栈（operand stack）会用来存储这个新变量的值。然后这个变量会存储到局部变量区中对应的位置上。如果这个变量不是基础类型的话，本地变量槽上存的就只是一个引用。这个引用指向堆的里一个对象。
  比如：
  int i = 5;

编译后就成了
0: bipush 5
2: istore_0

bipush

用来将一个字节作为整型数字压入操作数栈中，在这里5就会被压入操作数栈上。

istore_0

这是istore_这组指令集（译注：严格来说，这个应该叫做操作码，opcode ,指令是指操作码加上对应的操作数，oprand。不过操作码一般作为指令的助记符，这里统称为指令）中的一条，这组指令是将一个整型数字存储到本地变量中。n代表的是局部变量区中的位置，并且只能是0,1,2,3。再多的话只能用另一条指令istore了，这条指令会接受一个操作数，对应的是局部变量区中的位置信息。

这条指令执行的时候，内存布局是这样的：

class文件中的每一个方法都会包含一个局部变量表，如果这段代码在一个方法里面的话，你会在类文件的局部变量表中发现如下的一条记录。
LocalVariableTable:
Start Length Slot Name Signature
0 1 1 i I

字段
Java类里面的字段是作为类对象实例的一部分，存储在堆里面的（类变量对应存储在类对象里面）。关于字段的信息会添加到类文件里的field_info数组里，像下面这样：
ClassFile {
u4 magic;
u2 minor_version;
u2 major_version;
u2 constant_pool_count;
cp_info contant_pool[constant_pool_count – 1];
u2 access_flags;
u2 this_class;
u2 super_class;
u2 interfaces_count;
u2 interfaces[interfaces_count];
u2 fields_count;
field_info fields[fields_count];
u2 methods_count;
method_info methods[methods_count];
u2 attributes_count;
attribute_info attributes[attributes_count];
}

另外，如果变量被初始化了，那么初始化的字节码会加到构造方法里。
下面这段代码编译了之后：
public class SimpleClass {

public int simpleField = 100;

}

如果你用javap进行反编译，这个被添加到了field_info数组里的字段会多出一段描述信息。
public int simpleField;
Signature: I
flags: ACC_PUBLIC

初始化变量的字节码会被加到构造方法里，像下面这样：
public SimpleClass();
Signature: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: aload_0
5: bipush 100
7: putfield #2 // Field simpleField:I
10: return

aload_0

从局部变量数组中加载一个对象引用到操作数栈的栈顶。尽管这段代码看起来没有构造方法，但是在编译器生成的默认的构造方法里，就会包含这段初始化的代码。第一个局部变量正好是this引用，于是aload_0把this引用压到操作数栈中。aload_0是aload_指令集中的一条，这组指令会将引用加载到操作数栈中。n对应的是局部变量数组中的位置，并且也只能是0,1,2,3。还有类似的加载指令，它们加载的并不是对象引用，比如iload_,lload_,fload_,和dload_, 这里i代表int,l代表long,f代表float,d代表double。局部变量的在数组中的位置大于3的，得通过iload,lload,fload,dload,和aload进行加载，这些指令都接受一个操作数，它代表的是要加载的局部变量的在数组中的位置。

invokespecial

这条指令可以用来调用对象实例的构造方法，私有方法和父类中的方法。它是方法调用指令集中的一条，其它的还有invokedynamic, invokeinterface, invokespecial, invokestatic, invokevirtual.这里的invokespecial指令调用的是父类也就是java.lang.Object的构造方法。

bipush

它是用来把一个字节作为整型压到操作数栈中的，在这里100会被压到操作数栈里。

putfield

它接受一个操作数，这个操作数引用的是运行时常量池里的一个字段，在这里这个字段是simpleField。赋给这个字段的值，以及包含这个字段的对象引用，在执行这条指令的时候，都 会从操作数栈顶上pop出来。前面的aload_0指令已经把包含这个字段的对象压到操作数栈上了，而后面的bipush又把100压到栈里。最后putfield指令会将这两个值从栈顶弹出。执行完的结果就是这个对象的simpleField这个字段的值更新成了100。

上述代码执行的时候内存里面是这样的：

这里的putfield指令的操作数引用的是常量池里的第二个位置。JVM会为每个类型维护一个常量池，运行时的数据结构有点类似一个符号表，尽管它包含的信息更多。Java中的字节码操作需要对应的数据，但通常这些数据都太大了，存储在字节码里不适合，它们会被存储在常量池里面，而字节码包含一个常量池里的引用 。当类文件生成的时候，其中的一块就是常量池：
Constant pool:

1 = Methodref #4.#16 // java/lang/Object."<init>":()V

2 = Fieldref #3.#17 // SimpleClass.simpleField:I

3 = Class #13 // SimpleClass

4 = Class #19 // java/lang/Object

5 = Utf8 simpleField

6 = Utf8 I

7 = Utf8 <init>

8 = Utf8 ()V

9 = Utf8 Code

10 = Utf8 LineNumberTable

11 = Utf8 LocalVariableTable

12 = Utf8 this

13 = Utf8 SimpleClass

14 = Utf8 SourceFile

15 = Utf8 SimpleClass.java

16 = NameAndType #7:#8 // "<init>":()V

17 = NameAndType #5:#6 // simpleField:I

18 = Utf8 LSimpleClass;

19 = Utf8 java/lang/Object

常量字段（类常量）
带有final标记的常量字段在class文件里会被标记成ACC_FINAL.
比如
public class SimpleClass {

public final int simpleField = 100;

}

字段的描述信息会标记成ACC_FINAL:
public static final int simpleField = 100;
Signature: I
flags: ACC_PUBLIC, ACC_FINAL
ConstantValue: int 100

对应的初始化代码并不变：
4: aload_0
5: bipush 100
7: putfield #2 // Field simpleField:I

静态变量
带有static修饰符的静态变量则会被标记成ACC_STATIC：
public static int simpleField;
Signature: I
flags: ACC_PUBLIC, ACC_STATIC

不过在实例的构造方法中却再也找不到对应的初始化代码了。因为static变量会在类的构造方法中进行初始化，并且它用的是putstatic指令而不是putfiled。
static {};
Signature: ()V
flags: ACC_STATIC
Code:
stack=1, locals=0, args_size=0
0: bipush 100
2: putstatic #2 // Field simpleField:I
5: return

未完待续。

条件语句
像if-else, switch这样的流程控制的条件语句，是通过用一条指令来进行两个值的比较，然后根据结果跳转到另一条字节码来实现的。
循环语句包括for循环，while循环，它们的实现方式也很类似，但有一点不同，它们通常都会包含一条goto指令，以便字节码实现循环执行。do-while循环不需要goto指令，因为它的条件分支是在字节码的末尾。更多细节请参考循环语句一节。
有一些指令可以用来比较两个整型或者两个引用，然后执行某个分支，这些操作都能在单条指令里面完成。而像double,float,long这些值需要两条指令。首先得去比较两个值，然后根据结果，会把1，0或者-1压到栈里。最后根据栈顶的值是大于，等于或者小于0来判断应该跳转到哪个分支。
我们先来介绍下if-else语句，然后再详细介绍下分支跳转用到的几种不同的指令。
if-else
下面的这个简单的例子是用来比较两个整数的：
public int greaterThen(int intOne, int intTwo) {
if (intOne > intTwo) {
return 0;
} else {
return 1;
}
}

方法最后会编译成如下的字节码：
0: iload_1
1: iload_2
2: if_icmple 7
5: iconst_0
6: ireturn
7: iconst_1
8: ireturn

首先，通过iload_1, iload_2两条指令将两个入参压入操作数栈中。if_icmple会比较栈顶的两个值的大小。如果intOne小于或者等于intTwo的话，会跳转到第7行处的字节码来执行。可以看到这里和Java代码里的if语句的条件判断正好相反，这是因为在字节码里面，判断条件为真的话会跑到else分支里面去执行，而在Java代码里，判断为真会进入if块里面执行。换言之，if_icmple判断的是如果if条件不为真，然后跳过if块。if代码块里对应的代码是5，6处的字节码，而else块对应的是7，8处的。

下面的代码则稍微复杂了一点，它需要进行两次比较。
public int greaterThen(float floatOne, float floatTwo) {
int result;
if (floatOne > floatTwo) {
result = 1;
} else {
result = 2;
}
return result;
}

编译后会是这样：
0: fload_1
1: fload_2
2: fcmpl
3: ifle 11
6: iconst_1
7: istore_3
8: goto 13
11: iconst_2
12: istore_3
13: iload_3
14: ireturn

在这个例子中，首先两个参数会被fload_1和fload_2指令压入栈中。和上面那个例子不同的是，这里需要比较两回。fcmple先用来比较栈顶的floatOne和floatTwo，然后把比较的结果压入操作数栈中。
* floatOne > floatTwo –> 1
* floatOne = floatTwo –> 0
* floatOne < floatTwo –> -1
* floatOne or floatTwo = NaN –> 1

然后通过ifle进行判断，如果前面fcmpl的结果是< =0的话，则跳转到11行处的字节码去继续执行。
这个例子还有一个地方和前面不同的是，它只在方法末有一个return语句，因此在if代码块的最后，会有一个goto语句来跳过else块。goto语句会跳转到第13条字节码处，然后通过iload_3将存储在局部变量区第三个位置的结果压入栈中，然后就可以通过return指令将结果返回了。

除了比较数值的指令外，还有比较引用是否相等的(==)，以及引用是否等于null的（== null或者!=null)，以及比较对象的类型的（instanceof)。
if_icmp<cond>

这组指令用来比较操作数栈顶的两个整数，然后跳转到新的位置去执行。<cond>可以是：eq-等于，ne-不等于，lt-小于,le-小于等于，gt-大于， ge-大于等于。

if_acmp<cond>

这两个指令用来比较对象是否相等，然后根据操作数指定的位置进行跳转。

ifnonnull ifnull

这两个指令用来判断对象是否为null，然后根据操作数指定的位置进行跳转。

lcmp

这个指令用来比较栈顶的两个长整型，然后将结果值压入栈中： 如果value1>value2,压入1,如果value1==value2,压入0，如果value1<value2压入-1.

fcmp<cond> l g dcomp<cond>

这组指令用来比较两个float或者double类型的值，然后然后将结果值压入栈中：如果value1>value2,压入1,如果value1==value2,压入0，如果value1<value2压入-1. 指令可以以l或者g结尾，不同之处在于它们是如何处理NaN的。fcmpg和dcmpg指令把整数1压入操作数栈，而fcmpl和dcmpl把-1压入操作数栈。这确保了比较两个值的时候，如果其中一个不是数字（Not A Number, NaN)，比较的结果不会相等。比如判断if x > y（x和y都是浮点数）,就会用的fcmpl，如果其中一个值是NaN的话，-1会被压入栈顶，下一条指令则是ifle，如果分支小于0则跳转。因此如果有一个是NaN的话，ifle会跳过if块，不让它执行。

instanceof

如果栈顶对象的类型是指定的类的话，则将1压入栈中。这个指令的操作数指定的是某个类型在常量池的序号。如果对象为空或者不是对应的类型，则将0压入操作数栈中。

if<cond>

将栈顶值和0进行比较，如果条件为真，则跳转到指定的分支继续执行。这些指令通常用于较复杂的条件判断中，在一些单条指令无法完成的情况。比如验证方法调用的返回值。

switch语句
Java switch表达式的类型只能是char,byte,short,int,Character, Byte, Short,Integer,String或者enum。JVM为了支持switch语句，用了两个特殊的指令，叫做tableSwitch和lookupswitch，它们都只能操作整型数值。只能使用整型并不影响，因为char,byte,short和enum都可以提升成int类型。Java7开始支持String类型，下面我们会介绍到。tableswitch操作会比较快一些，不过它消耗的内存会更多。tableswitch会列出case分支里面最大值和最小值之间的所有值，如果判断的值不在这个范围内则直接跳转到default块执行，case中没有的值也会被列出，不过它们同样指向的是default块。拿下面的这个switch语句作为例子：
public int simpleSwitch(int intOne) {
switch (intOne) {
case 0:
return 3;
case 1:
return 2;
case 4:
return 1;
default:
return -1;
}
}

编译后会生成如下的字节码
0: iload_1
1: tableswitch {
default: 42
min: 0
max: 4
0: 36
1: 38
2: 42
3: 42
4: 40
}
36: iconst_3
37: ireturn
38: iconst_2
39: ireturn
40: iconst_1
41: ireturn
42: iconst_m1
43: ireturn

tableswitch指令里0，1，4的值和代码里的case语句一一对应，它们指向的是对应代码块的字节码。tableswitch指令同样有2,3的值，但代码中并没有对应的case语句，它们指向的是default代码块。当这条指令执行的时候，会判断操作数栈顶的值是否在最大值和最小值之间。如果不在的话，直接跳去default分支，也就是上面的42行处的字节码。为了确保能找到default分支，它都是出现在tableswitch指令的第一个字节（如果需要内存对齐的话，则在补齐了之后的第一个字节）。如果栈顶的值在最大最小值的范围内，则用它作为tableswtich内部的索引，定位到应该跳转的分支。比如1的话，就会跳转至38行处继续执行。下图会演示这条指令是如何执行的：

如果case语句里面的值取值范围太广了（也就是太分散了）这个方法就不太好了，因为它占用的内存太多了。因此当switch的case条件里面的值比较分散的时候，就会使用lookupswitch指令。这个指令会列出case语句里的所有跳转的分支，但它没有列出所有可能的值。当执行这条指令的时候，栈顶的值会和lookupswitch里的每个值进行比较，来确定要跳转的分支。执行lookupswitch指令的时候，JVM会在列表中查找匹配的元素，这和tableswitch比起来要慢一些，因为tableswitch直接用索引就定位到正确的位置了。当switch语句编译的时候，编译器必须去权衡内存的使用和性能的影响，来决定到底该使用哪条指令。下面的代码，编译器会生成lookupswitch语句：
public int simpleSwitch(int intOne) {
switch (intOne) {
case 10:
return 1;
case 20:
return 2;
case 30:
return 3;
default:
return -1;
}
}

生成后的字节码如下：
0: iload_1
1: lookupswitch {
default: 42
count: 3
10: 36
20: 38
30: 40
}
36: iconst_1
37: ireturn
38: iconst_2
39: ireturn
40: iconst_3
41: ireturn
42: iconst_m1
43: ireturn

为了确保搜索算法的高效（得比线性查找要快），这里会提供列表的长度，同时匹配的元素也是排好序的。下图演示了lookupswitch指令是如何执行的。

从Java7开始，switch语句增加了对String类型的支持。不过字节码中的switch指令还是只支持int类型，并没有增加对其它类型的支持。事实上switch语句对String的支持是分成两个步骤来完成的。首先，将每个case语句里的值的hashCode和操作数栈顶的值（译注：也就是switch里面的那个值，这个值会先压入栈顶）进行比较。这个可以通过lookupswitch或者是tableswitch指令来完成。结果会路由到某个分支上，然后调用String.equlals来判断是否确实匹配。最后根据equals返回的结果，再用一个tableswitch指令来路由到具体的case分支上去执行。
public int simpleSwitch(String stringOne) {
switch (stringOne) {
case "a":
return 0;
case "b":
return 2;
case "c":
return 3;
default:
return 4;
}
}

这个字符串的switch语句会生成下面的字节码：
0: aload_1
1: astore_2
2: iconst_m1
3: istore_3
4: aload_2
5: invokevirtual #2 // Method java/lang/String.hashCode:()I
8: tableswitch {
default: 75
min: 97
max: 99
97: 36
98: 50
99: 64
}
36: aload_2
37: ldc #3 // String a
39: invokevirtual #4 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
42: ifeq 75
45: iconst_0
46: istore_3
47: goto 75
50: aload_2
51: ldc #5 // String b
53: invokevirtual #4 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
56: ifeq 75
59: iconst_1
60: istore_3
61: goto 75
64: aload_2
65: ldc #6 // String c
67: invokevirtual #4 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
70: ifeq 75
73: iconst_2
74: istore_3
75: iload_3
76: tableswitch {
default: 110
min: 0
max: 2
0: 104
1: 106
2: 108
}
104: iconst_0
105: ireturn
106: iconst_2
107: ireturn
108: iconst_3
109: ireturn
110: iconst_4
111: ireturn

这段字节码所在的class文件里面，会包含如下的一个常量池。关于常量池可以看下JVM内部细节中的运行时常量池一节。
Constant pool:

2 = Methodref #25.#26 // java/lang/String.hashCode:()I

3 = String #27 // a

4 = Methodref #25.#28 // java/lang/String.equals:(Ljava/lang/Object;)Z

5 = String #29 // b

6 = String #30 // c

25 = Class #33 // java/lang/String

26 = NameAndType #34:#35 // hashCode:()I

27 = Utf8 a

28 = NameAndType #36:#37 // equals:(Ljava/lang/Object;)Z

29 = Utf8 b

30 = Utf8 c

33 = Utf8 java/lang/String

34 = Utf8 hashCode

35 = Utf8 ()I

36 = Utf8 equals

37 = Utf8 (Ljava/lang/Object;)Z

注意，在执行这个switch语句的时候，用到了两个tableswitch指令，同时还有数个invokevirtual指令，这个是用来调用String.equals()方法的。在下一篇文章中关于方法调用的那节，会详细介绍到这个invokevirtual指令。下图演示了输入为”b”的情况下，这个swith语句是如何执行的。

如果有几个分支的hashcode是一样的话，比如说“FB”和”Ea”，它们的hashCode都是28，得简单的调整下equals方法的处理流程来进行处理。在下面的这个例子中，34行处的字节码ifeg 42会跳转到另一个String.equals方法调用，而不是像前面那样执行lookupswitch指令，因为前面的那个例子中hashCode没有冲突。(译注：这里一般容易弄混淆，认为ifeq是字符串相等，为什么要跳到下一处继续比较字符串？其实ifeq是判断栈顶元素是否和0相等，而栈顶的值就是String.equals的返回值，而true,也就是相等，返回的是1，false返回的是0，因此ifeq为真的时候表明返回的是false，这会儿就应该继续进行下一个字符串的比较）
public int simpleSwitch(String stringOne) {
switch (stringOne) {
case "FB":
return 0;
case "Ea":
return 2;
default:
return 4;
}
}

这段代码会生成下面的字节码：
0: aload_1
1: astore_2
2: iconst_m1
3: istore_3
4: aload_2
5: invokevirtual #2 // Method java/lang/String.hashCode:()I
8: lookupswitch {
default: 53
count: 1
2236: 28
}
28: aload_2
29: ldc #3 // String Ea
31: invokevirtual #4 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
34: ifeq 42
37: iconst_1
38: istore_3
39: goto 53
42: aload_2
43: ldc #5 // String FB
45: invokevirtual #4 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
48: ifeq 53
51: iconst_0
52: istore_3
53: iload_3
54: lookupswitch {
default: 84
count: 2
0: 80
1: 82
}
80: iconst_0
81: ireturn
82: iconst_2
83: ireturn
84: iconst_4
85: ireturn

循环语句

if-else和switch这些条件流程控制语句都是先通过一条指令比较两个值，然后跳转到某个分支去执行。
for循环和while循环这些语句也类似，只不过它们通常都包含一个goto指令，使得字节码能够循环执行。do-while循环则不需要goto指令，因为它们的条件判断指令是放在循环体的最后来执行。
有一些操作码能在单条指令内完成整数或者引用的比较，然后根据结果跳转到某个分支继续执行。而比较double,long,float这些类型则需要两条指令。首先会将两个值进行比较，然后根据结果把1，-1，0压入操作数栈中。然后再根据栈顶的值是大于小于或者等于0，来决定下一步要执行的指令的位置。这些指令在上一篇文章中有详细的介绍。

while循环

while循环包含条件跳转指令比如if_icmpge 或者if_icmplt（前面有介绍）以及goto指令。如果判断条件不满足的话，会跳转到循环体后的第一条指令继续执行，循环结束（译注：这里判断条件和代码中的正好相反，如代码中是i<2，字节码内是i>=2，从字节码的角度看，是满足条件后循环中止）。循环体的末尾是一条goto指令，它会跳转到循环开始的地方继续执行，直到分支跳转的条件满足才终止。
public void whileLoop() {
int i = 0;
while (i < 2) {
i++;
}
}

编译完后是：
0: iconst_0
1: istore_1
2: iload_1
3: iconst_2
4: if_icmpge 13
7: iinc 1, 1
10: goto 2
13: return

if_icmpge指令会判断局部变量区中的1号位的变量（也就是i，译注：局部变量区从0开始计数，第0位是this)是否大于等于2，如果不是继续执行，如果是的话跳转到13行处，结束循环。goto指令使得循环可以继续执行，直到条件判断为真，这个时候会跳转到紧挨着循环体后边的return指令处。iinc是少数的几条能直接更新局部变量区里的变量的指令之一，它不用把值压到操作数栈里面就能直接进行操作。这里iinc指令把第1个局部变量（译注：第0个是this）自增1。

for循环和while循环在字节码里的格式是一样的。这并不奇怪，因为每个while循环都可以很容易改写成一个for循环。比如上面的while循环就可以改写成下面的for循环，当然了它们输出的字节码也是一样的：
public void forLoop() {
for(int i = 0; i < 2; i++) {

}

}

do-while循环

do-while循环和for循环，while循环非常类似，除了一点，它是不需要goto指令的，因为条件跳转指令在循环体的末尾，可以用它来跳转回循环体的起始处。
public void doWhileLoop() {
int i = 0;
do {
i++;
} while (i < 2);
}

这会生成如下的字节码：
0: iconst_0
1: istore_1
2: iinc 1, 1
5: iload_1
6: iconst_2
7: if_icmplt 2
10: return

指令码 助记符 说明

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下一条指令地址压入栈顶