头一回分析字节码

最新推荐文章于 2023-10-28 01:07:41 发布
最新推荐文章于 2023-10-28 01:07:41 发布
阅读量195 收藏 1
点赞数
分类专栏： Java-Virtual-Machine 文章标签： 字节码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luoyuchou/article/details/90183723
版权

基于Java SE 8虚拟机学习

1. Java字节码指令大全

参考官方规范文档 https://docs.oracle.com/javase/specs/index.html

Java虚拟机规范（Java SE 8版）

博客园大佬整理的Java字节码指令大全 https://www.cnblogs.com/longjee/p/8675771.html

2. 解析示例

字节码中每一步指令操作都与入栈出栈有关。

  • 每个方法（含构造函数）都对应一个栈帧，每个栈帧都有一个操作数栈；
  • 局部变量是一个数组，实例方法的栈帧中索引为0的那个元素通常为this，而静态方法的栈帧中则不是；
  • 调用实例方法前，会先将局部变量0（this）压入栈，若方法还接收其它参数，则依次将其它参数也压入栈然后传入（出栈）新的栈帧；

操作数栈：

  1. 后入先出（Last-In-First-Out）的列表为栈；
  2. 入栈即向栈中插入新元素；
  3. 最后入栈的元素处于栈顶；
  4. 最先入栈的元素在栈底；
  5. 出栈（弹出）则是取出最后入栈的元素；

2.1 示例一，以不同的方式初始化数值类型

该示例取自Numer系列代码解析中数值的“==”比较（未发布），描述基本类型与包装类型使用直接复制和new关键字新建实例时，字节码指令的差异。

public class Main {
    public static void main(String[] args) {
        int i1 = 9;
        int i2 = 9;
        System.out.println("基本类型与基本类型比较，结果为" + (i1 == i2));

        int i3 = 9;
        Integer i4 = 9;
        System.out.println("基本类型与包装类型比较，结果为" + (i3 == i4));

        int i5 = 9;
        Integer i6 = new Integer(9);
        System.out.println("基本类型与包装类型比较(使用new关键字)：" + (i5 == i6));
    }
}

反编译：javap -c -v Main.class

第一部分常量池，常量池中包含方法引用Methodref、字段引用Fieldref、类Class、字符串String、字段或方法结构NameAndType、字符常量值Utf8等。

简单取第一个常量进行说明：

#1 常量池序号为1的常量，是方法引用Methodref，其具体指向 #17 和 #44 两个常量，#1最终表现形式为java/lang/Object."<init>":()V，此处指向是点分隔（#17.#44）；

  • #17 常量池序号为17的常量，是类Class，其具体指向为 #61 这个常量，#17 最终表现形式为java/lang/Object；
    • #61 常量池序号为61的常量，字符常量值Utf8，表现形式为java/lang/Object；

#61到#17的过程就相当于Java的类装载方法：ClassLoader.getSystemClassLoader().loadClass("java.lang.Object");

  • #44 常量池序号为44的常量，是方法结构NameAndType，其具体指向 #18 和 #19 两个常量，#44 最终表现形式为"<init>":()V，此处指向是冒号分隔（#18:#19）；
    • #18 常量池序号为18的常量，字符常量值Utf8，表现形式为<init>；
    • #19 常量池序号为19的常量，字符常量值Utf8，表现形式为()V；

下方示例中所有非字符常量最终都会指向一个字符常量值Utf8

Classfile /C:/workspace/java_sdk/out/production/java_sdk/df/zhang/Main.class
  Last modified 2019-5-12; size 1431 bytes
  MD5 checksum bbb6c801e44a782a14d490c9103fe449
  Compiled from "Main.java"
public class df.zhang.Main
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #17.#44        // java/lang/Object."<init>":()V
   #2 = Fieldref           #45.#46        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = Class              #47            // java/lang/StringBuilder
   #4 = Methodref          #3.#44         // java/lang/StringBuilder."<init>":()V
   #5 = String             #48            // 基本类型与基本类型比较，结果为
   #6 = Methodref          #3.#49         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   #7 = Methodref          #3.#50         // java/lang/StringBuilder.append:(Z)Ljava/lang/StringBuilder;
   #8 = Methodref          #3.#51         // java/lang/StringBuilder.toString:()Ljava/lang/String;
   #9 = Methodref          #52.#53        // java/io/PrintStream.println:(Ljava/lang/String;)V
  #10 = Methodref          #13.#54        // java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
  #11 = String             #55            // 基本类型与包装类型比较，结果为
  #12 = Methodref          #13.#56        // java/lang/Integer.intValue:()I
  #13 = Class              #57            // java/lang/Integer
  #14 = Methodref          #13.#58        // java/lang/Integer."<init>":(I)V
  #15 = String             #59            // 基本类型与包装类型比较(使用new关键字)：
  #16 = Class              #60            // df/zhang/Main
  #17 = Class              #61            // java/lang/Object
  #18 = Utf8               <init>
  #19 = Utf8               ()V
  #20 = Utf8               Code
  #21 = Utf8               LineNumberTable
  #22 = Utf8               LocalVariableTable
  #23 = Utf8               this
  #24 = Utf8               Ldf/zhang/Main;
  #25 = Utf8               main
  #26 = Utf8               ([Ljava/lang/String;)V
  #27 = Utf8               args
  #28 = Utf8               [Ljava/lang/String;
  #29 = Utf8               i1
  #30 = Utf8               I
  #31 = Utf8               i2
  #32 = Utf8               i3
  #33 = Utf8               i4
  #34 = Utf8               Ljava/lang/Integer;
  #35 = Utf8               i5
  #36 = Utf8               i6
  #37 = Utf8               StackMapTable
  #38 = Class              #28            // "[Ljava/lang/String;"
  #39 = Class              #62            // java/io/PrintStream
  #40 = Class              #47            // java/lang/StringBuilder
  #41 = Class              #57            // java/lang/Integer
  #42 = Utf8               SourceFile
  #43 = Utf8               Main.java
  #44 = NameAndType        #18:#19        // "<init>":()V
  #45 = Class              #63            // java/lang/System
  #46 = NameAndType        #64:#65        // out:Ljava/io/PrintStream;
  #47 = Utf8               java/lang/StringBuilder
  #48 = Utf8               基本类型与基本类型比较，结果为
  #49 = NameAndType        #66:#67        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #50 = NameAndType        #66:#68        // append:(Z)Ljava/lang/StringBuilder;
  #51 = NameAndType        #69:#70        // toString:()Ljava/lang/String;
  #52 = Class              #62            // java/io/PrintStream
  #53 = NameAndType        #71:#72        // println:(Ljava/lang/String;)V
  #54 = NameAndType        #73:#74        // valueOf:(I)Ljava/lang/Integer;
  #55 = Utf8               基本类型与包装类型比较，结果为
  #56 = NameAndType        #75:#76        // intValue:()I
  #57 = Utf8               java/lang/Integer
  #58 = NameAndType        #18:#77        // "<init>":(I)V
  #59 = Utf8               基本类型与包装类型比较(使用new关键字)：
  #60 = Utf8               df/zhang/Main
  #61 = Utf8               java/lang/Object
  #62 = Utf8               java/io/PrintStream
  #63 = Utf8               java/lang/System
  #64 = Utf8               out
  #65 = Utf8               Ljava/io/PrintStream;
  #66 = Utf8               append
  #67 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #68 = Utf8               (Z)Ljava/lang/StringBuilder;
  #69 = Utf8               toString
  #70 = Utf8               ()Ljava/lang/String;
  #71 = Utf8               println
  #72 = Utf8               (Ljava/lang/String;)V
  #73 = Utf8               valueOf
  #74 = Utf8               (I)Ljava/lang/Integer;
  #75 = Utf8               intValue
  #76 = Utf8               ()I
  #77 = Utf8               (I)V

$ javap -c Main.class
Compiled from "Main.java"
public class df.zhang.Main {
  public df.zhang.Main();
    Code:
       0: aload_0                           
# 从局部变量0中加载对象引用this，入栈。上文描述类方法的栈帧中索引为0的那个元素通常为this
栈: {this}
       1: invokespecial #1                    // Method java/lang/Object."<init>":()V
# 调用初始化方法"<init>"初始化当前对象，将this传入新的栈帧。#1 对应Methodref // java/lang/Object."<init>":()V
栈: {}
       4: return
# 此处是默认构造函数，可将构造函数理解为一个返回类型为void的方法
# "<init>"方法是编译器在编译时命名的初始化方法，无法通过编码方式实现。
先将this入栈是因需要将this传入"<init>"方法的栈帧。代码可描述为
# init(this); Java编程中，调用实例方法不需要传入this

以下解析中，部分被""包含的文本是为了"高亮"

  public static void main(java.lang.String[]);
    Code:
栈: {}
       0: bipush        9                   
# [0]，"byte"转换为"int"类型，并入栈。"byte"取值范围为："-128 ~ 127"，因此"9"实际上是"byte"类型
栈: {9}
       2: istore_1                          
# [2]，栈顶元素数字"9"出栈，并保存到局部变量1（"LocalVariables[1]"）中，即数值9保存到变量"int i1"中
栈: {}
i1 = 9;
       3: bipush        9                   
# [3]，"byte"转换为"int"类型，并入栈。
栈: {9}
       5: istore_2                          
# [5]，栈顶元素数字"9"出栈，并保存到局部变量2（"LocalVariables[2]"）中，即数值9保存到变量"int i2"中
栈: {}
i2 = 9;
       6: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
# [6]，获取静态属性，"System.out"是类"System"中的静态常量，其类型为"java.io.PrintStream"  
栈: {System.out}                                  
       9: new           #3                  // class java/lang/StringBuilder
# [9]，新建"java.lang.StringBuilder"实例为"StringBuilder()"，此时并未初始化该实例
# 可以发现代码中使用+号连接的字符串，实际上是使用"java.lang.StringBuilder"进行拼装的
栈: {StringBuilder(), System.out}
      12: dup                               
# [12]，复制一份未经初始化的"StringBuilder()"引用入栈，为"StringBuilder_DUP()"
# 栈中"StringBuilder_DUP()"和"StringBuilder()"指向同一个对象
栈: {StringBuilder_DUP(), StringBuilder(), System.out}
      13: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V
# [13]，调用"<init>"方法初始化栈顶的"StringBuilder_DUP()"，"StringBuilder_DUP()"会被传入新的栈帧
# 因"<init>"无返回值，初始化结束后也不会有新的元素入栈
# 因此"init"("StringBuilder_DUP()"); 也就是初始化"StringBuilder()"
栈: {StringBuilder(), System.out}
      16: ldc           #5                  // String 基本类型与基本类型比较，结果为
# [16]，取得常量池中的字符串常量，并入栈。此处取出字符串常量池中（"基本类型与基本类型比较，结果为"）
栈: {"基本类型与基本类型比较，结果为", StringBuilder(), System.out}
      18: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
# [18]，调用"StringBuilder()"对象的实例方法"append()"，"基本类型与基本类型比较，结果为"和"StringBuilder()"会被传入新的栈帧
栈: {System.out}
# "StringBuilder().append()"方法执行结束后，会将"StringBuilder()"对象返回并入栈
栈: {StringBuilder(), System.out}
      21: iload_1                           
# [21]，从局部变量1（"LocalVariables[1]"）中加载"int"类型数值"9"，入栈
栈: {9, StringBuilder(), System.out}
      22: iload_2                           
# [22]，从局部变量2（"LocalVariables[2]"）中加载"int"类型数值"9"，入栈
栈: {9, 9, StringBuilder(), System.out}
      23: if_icmpne     30                  
# [23]，比较栈顶两个"int"类型的值，不相等就跳转到"[30]"
栈: {StringBuilder(), System.out}
      26: iconst_1                          
# [26]，"int"值1入栈，当值在-1 ~ 5范围内时会使用"iconst"指令，此处"1"值为"[23]"中的可能得到比较结果，代替"true"
栈: {1, StringBuilder(), System.out}
      27: goto          31                  
# [27]，跳转到位置31
      30: iconst_0                          
# [30]，"int"值0入栈，当值在-1 ~ 5范围内时会使用"iconst"指令，此处"0"值为"[23]"中的可能得到比较结果，代替"false"
栈: {0, StringBuilder(), System.out}
# "[26]"与"[30]"为流程控制，即等同于Java中的"if() {} else {}"
      31: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Z)Ljava/lang/StringBuilder;
由于代码运行结果中，(i1 == i2) = true，因此流程为[26, 27, 31]
栈: {1, StringBuilder(), System.out}     
# [31]，调用"StringBuilder()"对象的实例方法"append()"，"1"和"StringBuilder()"会被传入新的栈帧
栈: {System.out}
# "StringBuilder().append()"方法执行结束后，会将"StringBuilder()"对象返回并入栈
栈: {StringBuilder(), System.out}
      34: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
# [34]，调用"StringBuilder()"对象的实例方法"toString()"       
栈: {System.out}                             
# "toString()"方法执行结束后，会将一个"String"对象返回并入栈，该字符串值为："基本类型与基本类型比较，结果为true"
栈: {"基本类型与基本类型比较，结果为true", System.out} 
      37: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
# [37]，调用"System.out"的方法"println()"，"基本类型与基本类型比较，结果为true"会被传入新的栈帧
"System.out.println()"方法无返回值，则方法执行结束后不会有任何新元素入栈
栈: {}        
                                            

截止到以上，字节码中描述的代码如下：
        int i1 = 9;
        int i2 = 9;
        System.out.println("基本类型与基本类型比较，结果为" + (i1 == i2));

# -------------------------------------------------------------------------------------------------------------------- #

栈: {}
      40: bipush        9                   
# [40]，"byte"转换为"int"类型，并入栈。"byte"取值范围为："-128 ~ 127"，因此"9"实际上是"byte"类型
栈: {9}
      42: istore_3                          
# [42]，栈顶元素数字"9"出栈，并保存到局部变量3（"LocalVariables[3]"）中，即数值9保存到变量"int i3"中
栈: {}
int i3 = 9;
      43: bipush        9                   
# [43]，"byte"转换为"int"类型，并入栈。
栈: {9}
      45: invokestatic  #10                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
# [45]，调用"java.lang.Integer"的静态方法"valueOf()"新建"Integer()"实例，数值"9"会被传入新的栈帧
栈: {}
# "Integer.valueOf(9)"方法执行结束后，会将"Integer(9)"实例返回并入栈
栈: {Integer(9)}   
      48: astore        4                   
# [48]，栈顶元素"Integer(9)"出栈，并保存到局部变量4（"LocalVariables[4]"）中，即实例"Integer(9)"保存到变量"Integer i4"中
栈: {}  
Integer i4 = Integer(9);
      50: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
# [50]，获取静态属性，"System.out"是类"System"中的静态变量，其类型为"java.io.PrintStream"
栈: {System.out}                                                               
      53: new           #3                  // class java/lang/StringBuilder  
# [53]，新建"java.lang.StringBuilder"实例为"StringBuilder()"，此时并未初始化该实例
栈: {StringBuilder(), System.out}                                       
      56: dup                               
# [56]，复制一份未经初始化的"StringBuilder()"引用入栈，为"StringBuilder_DUP()"
# 栈中"StringBuilder_DUP()"和"StringBuilder()"指向同一个对象。
栈: {StringBuilder_DUP(), StringBuilder(), System.out}
      57: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V
# [57]，调用"<init>"方法初始化栈顶的"StringBuilder_DUP()"，"StringBuilder_DUP()"会被传入新的栈帧
# 因"<init>"无返回值，初始化结束后也不会有新的元素入栈。
# 因此"init"("StringBuilder_DUP()"); 也就是初始化"StringBuilder()"
栈: {StringBuilder(), System.out}                                            
      60: ldc           #11                 // String 基本类型与包装类型比较，结果为
# [60]，取得常量池中的字符串常量，并入栈。此处取出字符串常量池中（"基本类型与包装类型比较，结果为"）
栈: {"基本类型与包装类型比较，结果为", StringBuilder(), System.out}        
      62: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
# [62]，调用"StringBuilder()"对象的实例方法"append()"，"基本类型与包装类型比较，结果为"和"StringBuilder()"会被传入新的栈帧
栈: {System.out}
# "StringBuilder().append()"方法执行结束后，会将"StringBuilder()"对象返回并入栈
栈: {StringBuilder(), System.out}                              
      65: iload_3                           
# [65]，从局部变量3（"LocalVariables[3]"）中加载"int"类型数值"9"，入栈
栈: {9, StringBuilder(), System.out} 
      66: aload         4                   
# [66]，从局部变量4（"LocalVariables[4]"）中加载"Integer"类型引用"Integer(9)"，入栈
栈: {Integer(9), 9, StringBuilder(), System.out} 
      68: invokevirtual #12                 // Method java/lang/Integer.intValue:()I
# [68]，调用"Integer(9)"的实例方法"intValue()"，"Integer(9)"会被传入到新的栈帧
栈: {9, StringBuilder(), System.out} 
# "Integer(9).intValue()"方法执行结束后，会将数值"9"返回并入栈
栈: {9, 9, StringBuilder(), System.out}                                            
      71: if_icmpne     78  
栈: {StringBuilder(), System.out}
      74: iconst_1  
栈: {1, StringBuilder(), System.out}                     
      75: goto          79                  
      78: iconst_0            
栈: {0, StringBuilder(), System.out}             
      79: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Z)Ljava/lang/StringBuilder;
      82: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      85: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
栈: {} 

截止到以上，字节码中描述的代码如下：
        int i3 = 9;
        Integer i4 = 9;
        System.out.println("基本类型与包装类型比较，结果为" + (i3 == i4));

# -------------------------------------------------------------------------------------------------------------------- #

      88: bipush        9                   
      90: istore        5        
栈: {}           
      92: new           #13                 // class java/lang/Integer
# [92]，新建"java.lang.Integer"实例，此时并未初始化该实例
栈: {Integer(), System.out}
      95: dup                               
# [95]，复制未经初始化的"Integer()"引用入栈，，为"Integer_DUP()"
# 栈中"Integer_DUP()"和"Integer()"指向同一个对象。
栈: {Integer_DUP(), Integer(), System.out}
      96: bipush        9                   
# [96]，byte转换为int类型，并入栈。
栈: {9, Integer_DUP(), Integer(), System.out}
      98: invokespecial #14                 // Method java/lang/Integer."<init>":(I)V
# [98]，调用"<init>"方法初始化栈顶的"Integer_DUP()"，"Integer_DUP()"会被传入新的栈帧，
# 因"<init>"无返回值，初始化结束后也不会有新的元素入栈。
# 因此"init"("Integer_DUP()"); 也就是初始化"Integer()"
栈: {Integer(9), System.out}                    
     101: astore        6        
# [101]，栈顶元素引用"Integer(9)"出栈，并保存到局部变量6（"LocalVariables[6]"）中，即引用"Integer(9)"保存到变量"Integer i6"中          
栈: {System.out}     
Integer i6 = Integer(9);
     103: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
     106: new           #3                  // class java/lang/StringBuilder
     109: dup
     110: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V
     113: ldc           #15                 // String 基本类型与包装类型比较(使用new关键字)：
     115: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
     118: iload         5
     120: aload         6
     122: invokevirtual #12                 // Method java/lang/Integer.intValue:()I
     125: if_icmpne     132
     128: iconst_1
     129: goto          133
     132: iconst_0
     133: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Z)Ljava/lang/StringBuilder;
     136: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
     139: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
栈: {} 

截止到以上，字节码中描述的代码如下：
        int i5 = 9;
        Integer i6 = new Integer(9);
        System.out.println("基本类型与包装类型比较(使用new关键字)：" + (i5 == i6));

# -------------------------------------------------------------------------------------------------------------------- #

     ...
     437: return
}

2.2 示例二，创建对象时与字节码指令dup的说明

关于dup

示例一中已经涉及到指令dup，dup是单词duplicate（复制）的缩写，该指令复制栈顶一个字长的数据，然后将复制的数据压入栈顶。通过示例一可以发现，在包含dup的指令集中，上下文都会是

new
dup
invokespecial   # "<init>":()V
  • new，新建某个类型的实例并压入栈顶，此时该实例尚未初始化；
  • dup，复制该未初始化的实例并压入栈顶，此时栈中有两个同类型未初始化的实例；
  • invokespecial，调用类的初始化方法，此时会讲栈顶的元素弹出并传入到初始化方法的栈帧中作为初始元素；
  • 初始化方法不会返回任何数据，因此最后栈顶仍为new时新建的那个实例，同时该实例已初始化并可以使用。

根据以上简略分析可以得出，dup指令复制的是实例的引用，而不是复制实例的整块内存。故而能使两个复制与被复制实例中任一实例被初始化后，另外一个实例可以正常使用。

引入一个简单的集合例子进行描述

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Hello World");
        System.out.println(list);
    }
}

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

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/util/ArrayList
# [0]，新建集合实例"ArrayList()"，并将其压入栈顶。该集合具体类型为"java.util.ArrayList"
栈：{ArrayList()}
       3: dup
# [3]，复制栈顶元素"ArrayList()"为"ArrayList_DUP()"
栈：{ArrayList_DUP(), ArrayList()}
       4: invokespecial #3                  // Method java/util/ArrayList."<init>":()V
# [4]，调用将"java.util.ArrayList"的初始化方法"<init>"，栈顶元素"ArrayList_DUP"会被传入到初始化方法的栈帧（每个方法都有对应的栈帧）中
由于dup是复制引用，因此初始化"ArrayList_DUP()"时，实际上也是初始化"ArrayList()"
栈：{ArrayList()}
       7: astore_1
# [7]，将"ArrayList()"弹出并保存到局部变量1中，即"List<String> list"
List<String> list = ArrayList();
栈：{}
       8: aload_1
# [8]，即将调用"ArrayList()"的接口方法"add()"，因此需要将"ArrayList()"从局部变量1中取出并入栈
栈：{ArrayList()}
       9: ldc           #4                  // String Hello World
# [9]，从常量池取出字符串"Hello World"，并入栈；
栈：{"Hello World", ArrayList()}
      11: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
# [11]，调用接口"java.util.List"的方法"add(Object objec)"；
栈：{}
# "java.util.List.add(Object objec)"执行结束后会返回"boolean"类型值并入栈
# Java虚拟机中"boolean"类型值将会由"1"和"0"表示
      16: pop
# [16]，因不使用"add(Object objec)"的返回值，故"pop"弹出，将其舍弃
栈：{}
      17: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
# [17]，取得"System"中的静态常量"System.out"
栈: {System.out}
      20: aload_1
# [20]，再次加载局部变量1中的引用入栈
栈: {ArrayList(), System.out}
      21: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
# [21]，调用"java.io.PrintStream"的方法"println(Object object)"，将"ArrayList()"和"System.out"传入新的栈帧中
栈: {}
"System.out.println(Object object)"无返回值
      24: return
# [24]，栈中无元素，无需"pop"，直接返回"void"
}
择端
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构4————栈的概念和运算
冰炭不投day的博客
09-15 1736
数据结构1—————栈的概念和运算 一. 目录 数据结构1栈的概念和运算 一 目录 二 前言和引入 三 栈的概念 定义 相关概念 特点 栈的ADT定义 栈的存储结构 四 使用栈的顺序存储结构来实现栈的基本运算 结构定义 栈的初始化 入栈 出栈 其他 五 双栈邻接共享空间 简介和引入 结构体定义 初始化 入栈 出栈 六 链栈 简介和引入 结构体定义 初始化 入栈 出栈 其他
java源码编译为字节码的流程
走过路过不要错过
06-04 2331
1. 词法和语法分析 1.1 词法分析：将源代码的字符流转为Token集合，关键字、变量名、字面量和运算符都可成为Token，比如“int i = a”
汇编语言dup
e891377的专栏
06-24 1万+
dup的使用格式如下： db重复的次数 dup(重复的字节型数据)。 dw重复的次数 dup(重复的字型数据)。 dd重复的次数 dup(重复的双字数据)。 比如我们要定义一个容量为200个字节的栈段， stack segment db 200 dup (0) stack ends 参考资料：汇编语言王爽第二版 ...
Android 进阶之路：ASM 修改字节码，这样学就对了！
Hongyang
08-23 1万+
本文已授权个人公众号「鸿洋」原创发布。 恢复双休了，准备捡起来写博客这件事，会尝试写好每一篇博客，准备写一个「进阶之路」的系列，希望对你有用。 没错，看了很多 ASM 入门的文章，都感觉文章写的很轻松，站立的高度都太高了，我个人觉得想要能够编写 ASM 相关代码，能看懂字节码是必不可少的，所以本文会以字节码为切入点，带大家简单的入门一下 ASM。 Java Class 文件结构 大家都知道*.java 文件经过 javac 编译之后会生成 *.class 文件，*.class 文件会被 Java 虚拟.
Java字节码技术(一)static、final、volatile、synchronized关键字的字节码体现
hosaos的博客
09-23 3465
文章目录基本概念什么是字节码Javap命令查看字节码文件字节码文件解读static、final、volatile在字节码中的体现 基本概念 static：static修饰的变量被所有类实例共享，静态变量在其所在类被加载时进行初始化 final：final修饰的变量不可修改(基本类型值不能修改，引用类型引用不可修改)，final修饰的方法，不可重写、不可继承 volatile：volatile修饰的...
从一个class文件深入理解Java字节码结构
热门推荐
四月葡萄的博客
05-15 3万+
前言 我们都知道，Java程序最终是转换成class文件执行在虚拟机上的，那么class文件是个怎样的结构，虚拟机又是如何处理去执行class文件里面的内容呢，这篇文章带你深入理解Java字节码中的结构。 1.Demo源码 首先，编写一个简单的Java源码： package com.april.test; public class Demo { private int n...
Java的JVM字节码指令集详解【一万字】
终生学习践行者
04-11 4568
详细介绍了如何使用javap查看java方法中的字节码、以及各种字节码的含义，在文末还附有JVM字节码指令集表。
通过字节码分析JDK8中Lambda表达式编译及执行机制
马猴烧酒└(┐卍^o^)卍ﾄﾞｩﾙﾙﾙ~楪詩月「YUZURIHA SHIZUKI」
04-23 2万+
关于Lambda字节码相关的文章，很早之前就想写了，线上产品的后端技术，能快速迭代，除了得益于整体微服架构之外，语言层面上，也是通过Java8的lambda表达式的运用以及rxJava响应式编程框架，使代码更加简洁易维护，调用方式更加便捷。本文将介绍JVM中的方法调用相关的字节码指令，重点解析JDK7(JSR-292)之后新增的invokedynamic指令给lambda表达式的动态
Java字节码结构剖析一：常量池
拿笔小星的博客
10-14 2507
这篇博客开始，我打算手把手的带大家去解读一下JVM平台下的字节码文件（熟悉而又陌生的感觉）。众所周知，Class文件包含了我们定义的类或接口的信息。然后字节码又会被JVM加载到内存中，供JVM使用。那么，类信息到了字节码文件里，它们如何表示的，以及在字节码里是怎么分布的呢？带着这些问题，让我们去深入了解字节码文件吧。
Java字节码指令集的使用详细
09-05
理解并掌握Java字节码指令集对于优化Java代码性能、编写字节码级别的工具，或者进行代码分析和安全审计都是非常重要的。通过深入研究字节码指令，开发者可以更好地理解JVM如何执行程序，从而编写更高效、更可靠的...
XJad 字节码反编译工具
08-17
总的来说，XJad作为一款字节码反编译工具，它在Java发展历程中扮演了重要的角色，为开发者和安全专家提供了洞察字节码的窗口，促进了软件的分析和逆向工程。尽管现在有更多先进的替代品，但了解XJad的历史和工作原理...
Lua字节码分析工具
01-10
1. **字节码反汇编**：将二进制的字节码转换回可读的指令集，帮助开发者理解代码在Lua虚拟机（VM）中的执行流程。每个字节码指令对应一个操作，如加载常量、调用函数、跳转等。 2. **符号解析**：将数字常量和函数...
javassist试图简化Java字节码的编辑
08-06
Java字节码编辑是Java开发中的一个高级主题，它允许开发者在运行时修改或增强类的行为。`javassist`库正是这样一个工具，它为Java字节码操作提供了一个简洁的API，试图降低这个过程的复杂性。在Java世界中，字节码...
Java字节码优化框架
01-26
4. 输出生成：优化后的IR再转换回字节码或者Java源代码，生成优化后的class文件。 Soot的优化框架由一系列称为“Pack”的模块组成，每个Pack包含了多个相互协作的优化阶段。用户可以根据需求选择不同的Pack，或者...
JVM基础：字节码文件详解①
siaok的博客
10-28 1260
👉概述。
仿羊了个羊/王了个王带后台三消游戏源码
08-10
仿羊了个羊、王了个王带后台三消游戏源码，游戏玩儿法类似于养了个羊，有两种模式，一个是普通版，一个是王者荣耀版。
简历-求职简历-word-文件-简历模版免费分享-应届生-高颜值简历模版-个人简历模版-简约大气-大学生在校生-求职-实习
最新发布
08-10
简历-求职简历-word-文件-简历模版免费分享-应届生-高颜值简历模版-个人简历模版-简约大气-大学生在校生-求职-实习 简历是展示个人经历、技能和能力的重要文档，以下是一个常见的简历格式和内容模板，供您参考： 简历格式： 头部信息：包括姓名、联系方式（电话号码、电子邮件等）、地址等个人基本信息。 求职目标（可选）：简短描述您的求职意向和目标。 教育背景：列出您的教育经历，包括学校名称、所学专业、就读时间等。 工作经验：按时间顺序列出您的工作经历，包括公司名称、职位、工作时间、工作职责和成就等。 技能和能力：列出您的专业技能、语言能力、计算机技能等与职位相关的能力。 实习经验/项目经验（可选）：如果您有相关实习或项目经验，可以列出相关信息。 获奖和荣誉（可选）：列出您在学术、工作或其他领域获得的奖项和荣誉。 自我评价（可选）：简要描述您的个人特点、能力和职业目标。 兴趣爱好（可选）：列出您的兴趣爱好，展示您的多样性和个人素质。 参考人（可选）：如果您有可提供推荐的人员，可以在简历中提供其联系信息。 简历内容模板： 姓名: 联系方式: 地址: 求职目标: （简短描述您的求职意
ASP新闻管理系统设计与实现(源代码+论文).rar
08-10
资源包主要包含以下内容： ASP项目源码：每个资源包中都包含完整的ASP项目源码，这些源码采用了经典的ASP技术开发，结构清晰、注释详细，帮助用户轻松理解整个项目的逻辑和实现方式。通过这些源码，用户可以学习到ASP的基本语法、服务器端脚本编写方法、数据库操作、用户权限管理等关键技术。 数据库设计文件：为了方便用户更好地理解系统的后台逻辑，每个项目中都附带了完整的数据库设计文件。这些文件通常包括数据库结构图、数据表设计文档，以及示例数据SQL脚本。用户可以通过这些文件快速搭建项目所需的数据库环境，并了解各个数据表之间的关系和作用。 详细的开发文档：每个资源包都附有详细的开发文档，文档内容包括项目背景介绍、功能模块说明、系统流程图、用户界面设计以及关键代码解析等。这些文档为用户提供了深入的学习材料，使得即便是从零开始的开发者也能逐步掌握项目开发的全过程。 项目演示与使用指南：为帮助用户更好地理解和使用这些ASP项目，每个资源包中都包含项目的演示文件和使用指南。演示文件通常以视频或图文形式展示项目的主要功能和操作流程，使用指南则详细说明了如何配置开发环境、部署项目以及常见问题的解决方法。 毕业设计参考：对于正在准备毕业设计的学生来说，这些资源包是绝佳的参考材料。每个项目不仅功能完善、结构清晰，还符合常见的毕业设计要求和标准。通过这些项目，学生可以学习到如何从零开始构建一个完整的Web系统，并积累丰富的项目经验。
Lua 虚拟机执行字节码原理探索
在了解字节码的运行之前，我们首先要明确的是，这里的字节码指的是 Lua 语言的字节码，这是一种中间代码，用于 Lua 解释器执行。在 Lua 的世界里，字节码是由 Lua 编译器将源代码编译后的产物，它比源代码更接近机器...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值