Javap反汇编的使用

作者: 编程界的小学生 | 来源:发表于2017-04-25 10:35 被阅读0次

Javap反汇编的使用
玩转java bytecode第一篇从java到asm的转换。
JDK内置工具命令
Android Studio External Tool扩展工具
AndroidStudio配置JavaP反汇编
Tip-javap 指令的用途与使用
java的asm若干实践
JVM性能优化 - JDK内置命令工具
记录IDEA配置查看JVM字节码
javap命令小试牛刀

不废话，直接看Demo，定义自行Google
语法：javap -c xxx.class

Demo1

public class HelloWorld {
    public static void main(String[] args) {
        int i = 5;
    }
}

Code:
       0: iconst_5  //将常量5入栈
       1: istore_1  //将栈顶的（5）弹出，并存储在位置1的局部变量中（i中）
       2: return  //返回

Demo2

public class HelloWorld2 {
    public static void main(String[] args) {
        int i = 5;
        int j = i;
    }
}

Code:
       0: iconst_5  //将常量5入栈
       1: istore_1  //将栈顶的值（5）弹出，并存储在位置为1的局部变量中（i）
       2: iload_1   //将位置为1的局部变量（i）入栈
       3: istore_2  //将栈顶的值（i，也就是5）弹出，并存储在位置为2的局部变量中，即“j”中，此时“j”值为5
       4: return

Demo3

public class HelloWorld {
    public static void main(String[] args) {
        int i = 5;
        if(i < 10) {
            i --;
        }
    }
}

Code:
       0: iconst_5                //将常量5入栈
       1: istore_1                //将栈顶的值（5）弹出，并存储在位置为1的局部变量中（i）
       2: iload_1                 //将位置为1的局部变量（i）入栈
       3: bipush        10      //将整数10入栈
       5: if_icmpge     11    //如果第2步的值（5）大于等于第3步的值（10），则跳转到第11步，否则继续执行8
       8: iinc          1, -1     //把一个常量值（-1）加到第一个int类型的局部变量（i）上
      11: return

Demo4

public class HelloWorld {
    public static void main(String[] args) {
        int i = 5;
        for(int n = 0; n < 5; n ++) {
            i = i ++;
        }
    }
}

Code:
       0: iconst_5  //将常量5入栈
       1: istore_1  //将栈顶的值（5）弹出，并存储在位置为1的局部变量中（i）
       2: iconst_0 //将常量5入栈
       3: istore_2  //将栈顶的值（0）弹出，并存储在位置为2的局部变量中（n）
       4: goto  15  //跳转到第15步
       7: iload_1  //将位置为1的局部变量（i）入栈
       8: iinc  1, 1  //把一个常量值（1）加到第一个int类型的局部变量（i）上
      11: istore_1  //将栈顶的值弹出（i++）并存储在位置维1的局部变量上（i）
      12: iinc          2, 1 ////把一个常量值（1）加到第二个int类型的局部变量（n）上
      15: iload_2  //将位置为2的局部变量（n）入栈
      16: iconst_5 //将常量5入栈
      17: if_icmplt   7 //如果第15步的值（0）小于第16步的值（5），则跳转到第7步，否则继续执行20
      20: return

Demo5

public class HelloWorld {
    public static void main(String[] args) {
        add(12,23);
    }
    
    public static int add(int a, int b) {
        int c = 0;
        c = a + b;
        return c;
    }
}

 Code:
       0: iconst_0  //将常量0入栈
       1: istore_2  //将栈顶的值（0）弹出，并存储在位置为2的局部变量中。（c）
       2: iload_0  //把局部变量0（a）压栈
       3: iload_1  //把局部变量1（b）压栈
       4: iadd      //弹出两个变量，求和，将结果压栈
       5: istore_2  //将栈顶的值（a+b）弹出，并存储在位置为2的局部变量中（c）
       6: iload_2  //把局部变量2（c）压栈
       7: ireturn  //返回

Demo6、++i和i++

public class HelloWorld3 {
    public static void main(String[] args) {
        int i = 5;
        i = i++;
        int j = 6;
        j = ++j;
    }
}

Code:
       0: iconst_5        //把常量5入栈
       1: istore_1        //将栈顶的值弹出并存储在位置1的局部变量1中，即"i"中，此时"i"的值为5
       2: iload_1         //将位置1的局部变量压入栈，即"i"入栈,栈顶值为5
       3: iinc      1, 1  //将位置1的值加1，即"i"加1，此时"i"的值为6，注意这条指令不会改变栈顶的值
       6: istore_1        //将栈顶的值弹出并存储在位置1的局部变量中，即"i"中，此时"i"的值依然为5

       7: bipush     6    //将常量6入栈
       9: istore_2        //将栈顶的值弹出并存储在位置2的局部变量中，即"j"中，此时"j"的值为6
      10: iinc      2, 1  //将位置2的值加1，即"j"加1，此时"j"的值为7，注意这条指令不会改变栈顶的值
      13: iload_2         //将位置2的局部变量压入栈，即"j"入栈，栈顶值为7
      14: istore_2        //将栈顶的值弹出并存储在位置2的局部变量中，即"j"中，此时"j"的值为7

      15: return

Demo7、String和StringBuilder
（1）String

public class StringTest {
    public static void main(String[] args) {
        String str = "";
        for(int i = 0; i < 10; i ++) {
            str += i;
         }
    }
}

Code:
       0: ldc           #16                 // String                  //将String常量池入栈
       2: astore_1    //将引用类型值存入局部变量
       3: iconst_0   //将常量0入栈顶
       4: istore_2   //弹出栈顶的值，并存储在位置为2的局部变量中（i）
       5: goto          30    //跳转到第30行
       8: new           #18                 // class java/lang/StringBuilder              //每次for都new一个StringBuilder
      11: dup
      12: aload_1
      13: invokestatic  #20                 // Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
      16: invokespecial #26                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
      19: iload_2
      20: invokevirtual #29                 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
      23: invokevirtual #33                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      26: astore_1
      27: iinc          2, 1
      30: iload_2  //将位置2的局部变量压入栈，即"i"入栈
      31: bipush        10
      33: if_icmplt     8
      36: return

（2）StringBuilder

public class StringTest {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < 10; i ++) {
            sb.append(i);
        }
    }
}

 Code:
       0: new           #16                 // class java/lang/StringBuilder
       3: dup
       4: invokespecial #18                 // Method java/lang/StringBuilder."<init>":()V
       7: astore_1
       8: iconst_0
       9: istore_2
      10: goto          22
      13: aload_1
      14: iload_2
      15: invokevirtual #19                 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
      18: pop
      19: iinc          2, 1
      22: iload_2
      23: bipush        10
      25: if_icmplt     13
      28: return

对比可发现String每次都需要new一个StringBuilder，for十次就new了十个。而StringBuilder只是new了一次，其他的一直在追加。

Javap命令解释表