文章介绍

• 这篇文章讲解了在 Java 虚拟机上 Java 代码是如何编译成字节码并执行的。理解在 Java 虚拟机中 Java 代码如何别被编译成字节码并执行是非常重要的，因为这可以帮助你理解你的程序在运行时发生了什么。

• 这种理解不仅能确保你对语言特性有逻辑上的认识而且做具体的讨论时可以理解在语言特性上的妥协和副作用。

在字节码中每条指令（或操作码）前面的数字指示了这个字节的位置。

• 比如一条指令如 1: iconst_1 仅一个字节的长度，没有操作数，所以，接下来的字节码的位置为 2。

• 再比如这样一条指令 1: bipush 5 将会占两个字节，操作码 bipush 占一个字节，操作数 5 占一个字节。

• 那么，接下来的字节码的位置为 3，因为操作数占用的字节在位置 2。

Java 虚拟机是基于栈的架构。当一个方法包括初始化 main 方法执行，在栈上就会创建一个栈帧（frame），栈帧中存放着方法中的局部变量。

变量

局部变量

局部变量数组（local veriable array）包含在方法执行期间用到的所有变量包括一个引用变量 this，所有的方法参数和在方法体内定义的变量。

• 类方法（比如：static 方法）方法参数从 0 开始。

• 实例方法，第 0 个 slot 用来存放 this，所以参数需要从 1 开始哦！。

局部变量类型

• boolean

• byte

• char

• long

• short

• int

• float

• double

• reference

• returnAddress

• 除了 long 和 double 所有的类型在本地变量数组中占用一个 slot，long 和 double 需要两个连续的 slot 因为这两个类型为 64 位类型。

• 当在操作数栈上创建一个新的变量来存放一个这个新变量的值。这个新变量的值随后会被存放到局部变量数组对应的位置上。

• 如果这个变量不是一个基本类型，对应的 slot 上值存放指向这个变量的引用。这个引用指向存放在堆中的一个对象。

例如

int i = 5;

被编译为字节码为

0: bipush 5（占用两个字节）2: istore_0

bipush

将一个字节作为一个整数推送到操作数栈。在这个例子中 5 被推送到操作数栈。

istore_0

它是一组格式为 istore_n 操作数的其中之一，它们都是将一个整数存储到局部变量表中。

n 为在局部变量表中的位置，取值只能为 0,1,2,3。另一个操作码用作值大于 3 的情况，为 istore w，它将一个操作数放到本地变量数组中合适的位置，后面会详细进行介绍！。

上面的代码在内存中执行的情况如下：

这个类文件中对应每一个方法还包含一个局部变量表（local veribale table），如果这段代码被包含在一个方法中，在类文件对应于这个方法的本地变量表中你将会得到下面的实体（entry）：

LocalVariableTable:    Start  Length  Slot  Name   Signature      0      1      1     i         I

成员变量（类变量）

一个成员变量（field）被作为一个类实例（或对象）的一部分存储在堆上。关于这个成员变量的信息被定义到在类文件 class 字节码中 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: Iflags: 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

将本地变量数组 slot 中一个对象引用推送到操作数栈栈顶。

尽管，上面的代码中显示没有构造器对成员变量进行初始化，实际上，编译器会创建一个默认的构造器对成员变量进行初始化。

• 第一个局部变量实际上指向 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

invokespecial 指令用来调用实例方法，私有方法和当前类的父类的方法，构造方法等。

方式调用方法的操作码的一部分：

• invokedynamic（MethodHandle、Lamdba）

• invokeinterface（接口方法）

• invokespecial（构造器、父类方法、私有方法）

• invokestatic（静态方法）

• invokevirtual（实例方法）

invokespecial 指令在这段代码用来调用父类的构造器。

bipush

将一个字节作为一个整数推送到操作数栈。在这个例子中 100 被推送到操作数栈。

putfield

后面跟一个操作数 #2，这个操作数是运行时常量池（cp_info）中一个成员变量的引用，在这个例子中这个成员变量叫做 simpleField。给这个成员变量赋值，然后包含这个成员变量的对象一起被弹出操作数栈。

前面的aload_0指令将包含这个成员变量的对象和前面的bipush指令将 100 分别推送到操作数栈顶。putfield随后将它们都从操作数栈顶移除（弹出）。最终结果就是在这个对象上的成员变量 simpleFiled 的值被更新为 100。

上面的代码在内存中执行的情况如下：

java_class_variable_creation_byte_code

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 修饰的变量我们称之为常量，在类文件中我们标识为 ACC_FINAL。

例如：

public class SimpleClass {    public final int simpleField = 100;    public  int simpleField2 = 100;}

变量描述中多了一个 ACC_FINAL 参数：

public static final int simpleField = 100;Signature: Iflags: ACC_PUBLIC, ACC_FINALConstantValue: int 100

不过，构造器中的初始化操作并没有受影响：

4: aload_05: bipush        1007: putfield      #2                  // Field simpleField2:I

静态变量

被 static 修饰的变量，我们称之为静态类变量，在类文件中被标识为 ACC_STATIC，如下所示：

public static int simpleField;Signature: Iflags: ACC_PUBLIC, ACC_STATIC

在实例构造器中并没有发现用来对静态变量进行初始化的字节码。静态变量的初始化是在类构造器中，使用 putstatic 操作码而不是 putfield 字节码，是类构造器的一部分。

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 指令因为他们的条件分支位于字节码的尾部。更多的关于循环的细节可以查看 loops section。

一些操作码可以比较两个整数或者两个引用，然后在一个单条指令中执行一个分支。其它类型之间的比较如 double,long 或 float 需要分为两步来实现。

首先，进行比较后将 1,0 或-1 推送到操作数栈顶。接下来，基于操作数栈上值是大于，小于还是等于 0 执行一个分支。

首先，我们拿 if-else 语句为例进行讲解，其他用来进行分支跳转的不同的类型的指令将会被包含在下面的讲解之中。

if-else

下面的代码展示了一条简单的用来比较两个整数大小的 if-else 语句。

public int greaterThen(int intOne, int intTwo) {    if (intOne > intTwo) {        return 0;    } else {        return 1;    }}

这个方法编译成如下的字节码：

0: iload_11: iload_22: if_icmple        75: iconst_06: ireturn7: iconst_18: ireturn

• 首先，使用 iload_1 和 iload_2 将两个参数推送到操作数栈。

• 然后，使用 if_icmple 比较操作数栈栈顶的两个值。

• 如果 intOne 小于或等于 intTwo，这个操作数分支变成字节码 7，跳转到字节码指令行 7line。

注意，在 Java 代码中 if 条件中的测试与在字节码中是完全相反的，因为在字节码中如果 if 条件语句中的测试成功执行，则执行 else 语句块中的内容，而在 Java 代码，如果 if 条件语句中的测试成功执行，则执行 if 语句块中的内容。

换句话说，if_icmple 指令是在测试如果 if 条件不为 true，则跳过 if 代码块。if 代码块的主体是序号为 5 和 6 的字节码，else 代码块的主体是序号为 7 和 8 的字节码。

java_if_else_byte_code

下面的代码示例展示了一个稍微复杂点的例子，需要一个两步比较：

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          1311: iconst_212: istore_313: iload_314: ireturn

在这个例子中，首先使用 fload_1 和 fload_2 将两个参数推送到操作数栈栈顶。这个例子与上一个例子不同在于这个需要两步比较。fcmpl 首先比较 floatOne 和 floatTwo，然后将结果推送到操作数栈栈顶。如下所示：

floatOne > floatTwo -> 1
floatOne = floatTwo -> 0
floatOne < floatTwo -> -1 floatOne or floatTwo= Nan -> 1

接下来，如果 fcmpl 的结果是<=0，ifle 用来跳转到索引为 11 处的字节码。

• 这个例子和上一个例子的不同之处还在于这个方法的尾部只有一个单个的 return 语句，而在 if 语句块的尾部还有一条 goto 指令用来防止 else 语句块被执行。

• goto 分支对应于序号为 13 处的字节码 iload_3，用来将局部变量表中第三个 slot 中存放的结果推送扫操作数栈顶，这样就可以由 return 语句来返回。

java_if_else_byte_code_extra_goto

和存在进行数值比较的操作码一样，也有进行引用相等性比较的操作码比如==，与 null 进行比较比如 == null 和 != null，测试一个对象的类型比如 instanceof。

• if_cmp eq ne lt le gt ge 这组操作码用于操作数栈栈顶的两个整数并跳转到一个新的字节码处。可取的值有：

eq – 等于ne – 不等于lt – 小于le – 小于或等于gt – 大于ge – 大于或等于

• if_acmp eq ne 这两个操作码用于测试两个引用相等（eq）还是不相等（ne），然后跳转到由操作数指定的新一个新的字节码处。

• ifnonnull/ifnull这两个字节码用于测试两个引用是否为 null 或者不为 null，然后跳转到由操作数指定的新一个新的字节码处。

• lcmp这个操作码用于比较在操作数栈栈顶的两个整数，然后将一个值推送到操作数栈，如下所示：

如果 value1 > value2 -> 推送 1 如果 value1 = value2 -> 推送 0 如果 value1 < value2 -> 推送-1

fcmp l g / dcmp l g 这组操作码用于比较两个 float 或者 double 值，然后将一个值推送的操作数栈，如下所示：

如果 value1 > value2 -> 推送 1 如果 value1 = value2 -> 推动 0 如果 value1 < value2 -> 推送-1

以 l 或 g 类型操作数结尾的差别在于它们如何处理 NaN。

• fcmpg 和 dcmpg 将 int 值 1 推送到操作数栈而 fcmpl 和 dcmpl 将-1 推送到操作数栈。这就确保了在测试时如果两个值中有一个为 NaN（Not A Number），测试就不会成功。

• 比如，如果 x > y（这里 x 和 y 都为 doube 类型），x 和 y 中如果有一个为 NaN，fcmpl 指令就会将-1 推送到操作数栈。

• 接下来的操作码总会是一个 ifle 指令，如果这是栈顶的值小于 0，就会发生分支跳转。结果，x 和 y 中有一个为 NaN，ifle 就会跳过 if 语句块，防止 if 语句块中的代码被执行到。

• instanceof 如果操作数栈栈顶的对象一个类的实例，这个操作码将一个 int 值 1 推送到操作数栈。这个操作码的操作数用来通过提供常量池中的一个索引来指定类。如果这个对象为 null 或者不是指定类的实例则 int 值 0 就会被推送到操作数栈。

if eq ne lt le gt ge所有的这些操作码都是用来将操作数栈栈顶的值与 0 进行比较，然后跳转到操作数指定位置的字节码处。

如果比较成功，这些指令总是被用于更复杂的，不能用一条指令完成的条件逻辑，例如，测试一个方法调用的结果。

switch

一个 Java switch 表达式允许的类型可以为 char,byte,short,int,Character,Byte,Short.Integer,String 或者一个 enum 类型。为了支持 switch 语句。

Java 虚拟机使用两个特殊的指令：tableswitch 和 lookupswitch，它们背后都是通过整数值来实现的。仅使用整数值并不会出现什么问题，因为 char,byte,short 和 enum 类型都可以在内部被提升为 int 类型。

在 Java7 中添加对 String 的支持，背后也是通过整数来实现的。tableswitch 通过速度更快，但是通常占用更多的内存。

tableswitch 通过列举在最小和最大的 case 值之间所有可能的 case 值来工作。最小和最大值也会被提供，所以如果 switch 变量不在列举的 case 值的范围之内，JVM 就会立即跳到 default 语句块。在 Java 代码没有提供的 case 语句的值也会被列出，不过指向 default 语句块，确保在最小值和最大值之间的所有值都会被列出来。

例如，执行下面的 swicth 语句：

public int simpleSwitch(int intOne) {    switch (intOne) {        case 0:            return 3;        case 1:            return 2;        case 4:            return 1;        default:            return -1;    }

这段代码产生如下的字节码：

0: iload_11: tableswitch   {         default: 42             min: 0             max: 4               0: 36               1: 38               2: 42               3: 42               4: 40    }36: iconst_337: ireturn38: iconst_239: ireturn40: iconst_141: ireturn42: iconst_m143: ireturn

tableswitch 指令拥有值 0,1 和 4 去匹配 Java 代码中提供的 case 语句，每一个值指向它们对应的代码块的字节码。tableswitch 指令还存在值 2 和 3，它们并没有在 Java 代码中作为 case 语句提供，它们都指向 default 代码块。当这些指令被执行时，在操作数栈栈顶的值会被检查看是否在最大值和最小值之间。如果值不在最小值和最大值之间，代码执行就会跳到 default 分支，在上面的例子中它位于序号为 42 的字节码处。为了确保 default 分支的值可以被 tableswitch 指令发现，所以它总是位于第一个字节处（在任何需要的对齐补白之后）。如果值位于最小值和最大值之间，就用于索引 tableswitch 内部，寻找合适的字节码进行分支跳转。

例如，值为，则代码执行会跳转到序号为 38 处的字节码。 下图展示了这个字节码是如何执行的：

java_switch_tableswitch_byte_code

如果在 case 语句中的值”离得太远“（比如太稀疏），这种方法就会不太可取，因为它会占用太多的内存。当 switch 中 case 比较稀疏时，可以使用 lookupswitch 来替代 tableswitch。lookupswitch 会为每一个 case 语句例举出分支对应的字节码，但是不会列举出所有可能的值。

• 当执行 lookupswitch 时，位于操作数栈栈顶的值会同 lookupswitch 中的每一个值进行比较，从而决定正确的分支地址。使用 lookupswitch，JVM 会查找在匹配列表中查找正确的匹配，这是一个耗时的操作。而使用 tableswitch，JVM 可以快速定位到正确的值。

• 当一个选择语句被编译时，编译器必须在内存和性能二者之间做出权衡，决定选择哪一种选择语句。下面的代码，编译器会使用 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_11: lookupswitch  {         default: 42           count: 3              10: 36              20: 38              30: 40    }36: iconst_137: ireturn38: iconst_239: ireturn40: iconst_341: ireturn42: iconst_m143: ireturn

为了更高效的搜索算法（比线性搜索更高效），lookupswitch 会提供匹配值个数并对匹配值进行排序。下图显示了上述代码是如何被执行的：

java_switch_lookupswitch_byte_code

String switch

在 Java7 中，switch 语句增加了对字符串类型的支持。虽然现存的实现 switch 语句的操作码仅支持 int 类型且没有新的操作码加入。字符串类型的 switch 语句分为两个部分完成。首先，比较操作数栈栈顶和每个 case 语句对应的值之间的哈希值。这一步可以通过 lookupswitch 或者 tableswitch 来完成（取决于哈希值的稀疏度）。

这也会导致一个分支对应的字节码去调用 String.equals()进行一次精确地匹配。一个 tableswitch 指令将利用 String.equlas()的结果跳转到正确的 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_237: ldc           #3                  // String a39: invokevirtual #4                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z42: ifeq          7545: iconst_046: istore_347: goto          7550: aload_251: ldc           #5                  // String b53: invokevirtual #4                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z56: ifeq          7559: iconst_160: istore_361: goto          7564: aload_265: ldc           #6                  // String c67: invokevirtual #4                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z70: ifeq          7573: iconst_274: istore_375: iload_376: tableswitch   {         default: 110             min: 0             max: 2               0: 104               1: 106               2: 108       }104: iconst_0105: ireturn106: iconst_2107: ireturn108: iconst_3109: ireturn110: iconst_4111: ireturn

这个类包含这段字节码，同时也包含下面由这段字节码引用的常量池值。了解更多关于常量池的知识可以查看 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”时代码是如何执行的：

如果不同 case 匹配到的哈希值相同，比如，字符串”FB”和”Ea”的哈希值都是 28。这可以通过像下面这样轻微的调整 equlas 方法流来处理。注意，序号为 34 处的字节码：ifeg 42 去调用另一个 String.equals() 来替换上一个不存在哈希冲突的例子中的 lookupsswitch 操作码。

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_229: ldc           #3                  // String Ea31: invokevirtual #4                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z34: ifeq          4237: iconst_138: istore_339: goto          5342: aload_243: ldc           #5                  // String FB45: invokevirtual #4                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z48: ifeq          5351: iconst_052: istore_353: iload_354: lookupswitch  {         default: 84           count: 2               0: 80               1: 82    }80: iconst_081: ireturn82: iconst_283: ireturn84: iconst_485: ireturn

循环

• 条件流控制，比如，if-else 语句和 switch 语句都是通过使用一条指令来比较两个值然后跳转到相应的字节码来实现的。了解更多关于条件语句的细节可以查看 conditionals section 。

• 循环包括 for 循环和 while 循环也是通过类似的方法来实现的除了它们通常一个 goto 指令来实现字节码的循环。do-while 循环不需要任何 goto 指令，因为它们的条件分支位于字节码的末尾。

• 一些字节码可以比较两个整数或者两个引用，然后使用一个单个的指令执行一个分支。其他类型之间的比较如 double,long 或者 float 需要两步来完成。首先，执行比较，将 1,0,或者-1 推送到操作数栈栈顶。接下来，基于操作数栈栈顶的值是大于 0，小于 0 还是等于 0 执行一个分支。了解更多关于进行分支跳转的指令的细节可以 see above 。

while 循环

while 循环一个条件分支指令比如 if_fcmpge 或 if_icmplt（如上所述）和一个 goto 语句。在循环过后就理解执行条件分支指令，如果条件不成立就终止循环。循环中最后一条指令是 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, 110: goto            213: return

if_cmpge 指令测试在位置 1 处的局部变量是否等于或者大于 10，如果大于 10,这个指令就跳到序号为 14 的字节码处完成循环。goto 指令保证字节码循环直到 if_icmpge 条件在某个点成立，循环一旦结束，程序执行分支立即就会跳转到 return 指令处。iinc 指令是为数不多的在操作数栈上不用加载(load)和存储(store)值可以直接更新一个局部变量的指令之一。在这个例子中，iinc 将第一个局部变量的值加 1。

for 循环

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   210: return