Java代码优化之解读JVM字节码

最新推荐文章于 2024-08-13 23:36:01 发布
最新推荐文章于 2024-08-13 23:36:01 发布
阅读量238 收藏 1
点赞数
分类专栏： JVM优化 文章标签： 代码优化 JVM字节码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44950987/article/details/100570710
版权

前面我们通过tomcat本身的参数以及jvm的参数对tomcat做了优化，其实要想将应用程 序跑的更快、效率更高，除了对tomcat容器以及jvm优化外，应用程序代码本身如果写 的效率不高的，那么也是不行的，所以，对于程序本身的优化也就很重要了。

对于程序本身的优化，可以借鉴很多前辈们的经验，但是有些时候，在从源码角度方面 分析的话，不好鉴别出哪个效率高，如对字符串拼接的操作，是直接“+”号拼接效率高还 是使用StringBuilder效率高？
这个时候，就需要通过查看编译好的class文件中字节码，就可以找到答案。

我们都知道，java编写应用，需要先通过javac命令编译成class文件，再通过jvm执行， jvm执行时是需要将class文件中的字节码载入到jvm进行运行的。

通过javap命令查看class文件的字节码内容

首先，看一个简单的Test1类的代码：

package cn.itcast.jvm; 
public class Test1 {
    public static void main(String[] args) {
        int a = 2;
        int b = 5;
        int c = b - a;
        System.out.println(c);
    }
}

通过javap命令查看class文件中的字节码的内容

javap ‐v Test1.class > Test1.txt 

javap用法: javap <options> <classes> 
其中, 可能的选项包括: 
	‐help ‐‐help ‐? 输出此用法消息 
	‐version 版本信息 
	‐v ‐verbose 输出附加信息 
	‐l 输出行号和本地变量表 
	‐public 仅显示公共类和成员 
	‐protected 显示受保护的/公共类和成员 
	‐package 显示程序包/受保护的/公共类 和成员 (默认) 
	‐p ‐private 显示所有类和成员 
	‐c 对代码进行反汇编 
	‐s 输出内部类型签名 
	‐sysinfo 显示正在处理的类的 
			 系统信息 (路径, 大小, 日期, MD5 散列) 
	‐constants 显示最终常量 
	‐classpath <path> 指定查找用户类文件的位置 
	‐cp <path> 指定查找用户类文件的位置 
	‐bootclasspath <path> 覆盖引导类文件的位置

查看Test1.txt文件，内容如下：

Classfile /C:/mydocuments/IdeaProjects/basic-code/out/production/day08/cn/itcast/jvm/Test1.class
  Last modified 2019-9-6; size 577 bytes
  MD5 checksum 452ef3b500e9ffabf352261a0132f07c
  Compiled from "Test1.java"
public class cn.itcast.jvm.Test1
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #5.#23         // java/lang/Object."<init>":()V
   #2 = Fieldref           #24.#25        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = Methodref          #26.#27        // java/io/PrintStream.println:(I)V
   #4 = Class              #28            // cn/itcast/jvm/Test1
   #5 = Class              #29            // java/lang/Object
   #6 = Utf8               <init>
   #7 = Utf8               ()V
   #8 = Utf8               Code
   #9 = Utf8               LineNumberTable
  #10 = Utf8               LocalVariableTable
  #11 = Utf8               this
  #12 = Utf8               Lcn/itcast/jvm/Test1;
  #13 = Utf8               main
  #14 = Utf8               ([Ljava/lang/String;)V
  #15 = Utf8               args
  #16 = Utf8               [Ljava/lang/String;
  #17 = Utf8               a
  #18 = Utf8               I
  #19 = Utf8               b
  #20 = Utf8               c
  #21 = Utf8               SourceFile
  #22 = Utf8               Test1.java
  #23 = NameAndType        #6:#7          // "<init>":()V
  #24 = Class              #30            // java/lang/System
  #25 = NameAndType        #31:#32        // out:Ljava/io/PrintStream;
  #26 = Class              #33            // java/io/PrintStream
  #27 = NameAndType        #34:#35        // println:(I)V
  #28 = Utf8               cn/itcast/jvm/Test1
  #29 = Utf8               java/lang/Object
  #30 = Utf8               java/lang/System
  #31 = Utf8               out
  #32 = Utf8               Ljava/io/PrintStream;
  #33 = Utf8               java/io/PrintStream
  #34 = Utf8               println
  #35 = Utf8               (I)V
{
  public cn.itcast.jvm.Test1();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcn/itcast/jvm/Test1;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=4, args_size=1
         0: iconst_2
         1: istore_1
         2: iconst_5
         3: istore_2
         4: iload_2
         5: iload_1
         6: isub
         7: istore_3
         8: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        11: iload_3
        12: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
        15: return
      LineNumberTable:
        line 5: 0
        line 6: 2
        line 7: 4
        line 8: 8
        line 9: 15
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      16     0  args   [Ljava/lang/String;
            2      14     1     a   I
            4      12     2     b   I
            8       8     3     c   I
}
SourceFile: "Test1.java"

内容大致分为4个部分：
第一部分：显示了生成这个class的java源文件、版本信息、生成时间等。
第二部分：显示了该类中所涉及到常量池，共35个常量。
第三部分：显示该类的构造器，编译器自动插入的。
第四部分：显示了main方的信息。（这个是需要我们重点关注的）

常量池

官方文档：https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.4-140
在这里插入图片描述

描述符

字段描述符

官网：https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.2
在这里插入图片描述

方法描述符

官网：https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.3
示例：
The method descriptor for the method:

Object m(int i, double d, Thread t) {...}

is：

(IDLjava/lang/Thread;)Ljava/lang/Object;

解读方法字节码

public static void main(java.lang.String[]); 
	descriptor: ([Ljava/lang/String;)V //方法描述，V表示该方法的放回值为 void
	flags: ACC_PUBLIC, ACC_STATIC // 方法修饰符，public、static的 
	Code: 
	// stack=2,操作栈的大小为2、locals=4，本地变量表大小，args_size=1, 参数 的个数 
	stack=2, locals=4, args_size=1 
		0: iconst_2 //将数字2值压入操作栈，位于栈的最上面 
		1: istore_1 //从操作栈中弹出一个元素(数字2)，放入到本地变量表中，位 于下标为1的位置（下标为0的是this） 
		2: iconst_5 //将数字5值压入操作栈，位于栈的最上面 
		3: istore_2 //从操作栈中弹出一个元素(5)，放入到本地变量表中，位于第 下标为2个位置
		4: iload_2 //将本地变量表中下标为2的位置元素压入操作栈（5） 
		5: iload_1 //将本地变量表中下标为1的位置元素压入操作栈（2） 
		6: isub //操作栈中的2个数字相减 
		7: istore_3 // 将相减的结果压入到本地本地变量表中，位于下标为3的位置 // 通过#2号找到对应的常量，即可找到对应的引用 
		8: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream; 
		11: iload_3 //将本地变量表中下标为3的位置元素压入操作栈（3） 
		// 通过#3号找到对应的常量，即可找到对应的引用，进行方法调用 
		12: invokevirtual #3 // Method java/io/PrintStream.println:(I)V 
		15: return //返回 
		LineNumberTable: //行号的列表 
		line 6: 0 
		line 7: 2 
		line 8: 4 
		line 9: 8 
		line 10: 15 
		LocalVariableTable: // 本地变量表 
		Start Length Slot Name Signature 
		    0      16   0 args [Ljava/lang/String; 
		    2      14   1    a  I 
		    4      12   2    b  I 
		    8      8    3    c  I 
}
SourceFile: "Test1.java"
图解

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

研究i++与++i的不同

我们都知道，i++表示，先返回再+1，++i表示，先+1再返回。它的底层是怎么样的呢? 我 们一起探究下。
编写测试代码：

public class Test2 {
    public static void main(String[] args) {
        new Test2().method1();
        new Test2().method2();
    }

    public void method1() {
        int i = 1;
        int a = i++;
        System.out.println(a); //打印1
    }

    public void method2() {
        int i = 1;
        int a = ++i;
        System.out.println(a);//打印2 }
    }
}
查看class字节码
Classfile /C:/mydocuments/IdeaProjects/basic-code/out/production/day08/cn/itcast/jvm/Test2.class
  Last modified 2019-9-6; size 791 bytes
  MD5 checksum 1ad50e88b29f2a26a7343754340ba11b
  Compiled from "Test2.java"
public class cn.itcast.jvm.Test2
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #8.#27         // java/lang/Object."<init>":()V
   #2 = Class              #28            // cn/itcast/jvm/Test2
   #3 = Methodref          #2.#27         // cn/itcast/jvm/Test2."<init>":()V
   #4 = Methodref          #2.#29         // cn/itcast/jvm/Test2.method1:()V
   #5 = Methodref          #2.#30         // cn/itcast/jvm/Test2.method2:()V
   #6 = Fieldref           #31.#32        // java/lang/System.out:Ljava/io/PrintStream;
   #7 = Methodref          #33.#34        // java/io/PrintStream.println:(I)V
   #8 = Class              #35            // java/lang/Object
   #9 = Utf8               <init>
  #10 = Utf8               ()V
  #11 = Utf8               Code
  #12 = Utf8               LineNumberTable
  #13 = Utf8               LocalVariableTable
  #14 = Utf8               this
  #15 = Utf8               Lcn/itcast/jvm/Test2;
  #16 = Utf8               main
  #17 = Utf8               ([Ljava/lang/String;)V
  #18 = Utf8               args
  #19 = Utf8               [Ljava/lang/String;
  #20 = Utf8               method1
  #21 = Utf8               i
  #22 = Utf8               I
  #23 = Utf8               a
  #24 = Utf8               method2
  #25 = Utf8               SourceFile
  #26 = Utf8               Test2.java
  #27 = NameAndType        #9:#10         // "<init>":()V
  #28 = Utf8               cn/itcast/jvm/Test2
  #29 = NameAndType        #20:#10        // method1:()V
  #30 = NameAndType        #24:#10        // method2:()V
  #31 = Class              #36            // java/lang/System
  #32 = NameAndType        #37:#38        // out:Ljava/io/PrintStream;
  #33 = Class              #39            // java/io/PrintStream
  #34 = NameAndType        #40:#41        // println:(I)V
  #35 = Utf8               java/lang/Object
  #36 = Utf8               java/lang/System
  #37 = Utf8               out
  #38 = Utf8               Ljava/io/PrintStream;
  #39 = Utf8               java/io/PrintStream
  #40 = Utf8               println
  #41 = Utf8               (I)V
{
  public cn.itcast.jvm.Test2();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcn/itcast/jvm/Test2;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: new           #2                  // class cn/itcast/jvm/Test2
         3: dup
         4: invokespecial #3                  // Method "<init>":()V
         7: invokevirtual #4                  // Method method1:()V
        10: new           #2                  // class cn/itcast/jvm/Test2
        13: dup
        14: invokespecial #3                  // Method "<init>":()V
        17: invokevirtual #5                  // Method method2:()V
        20: return
      LineNumberTable:
        line 5: 0
        line 6: 10
        line 7: 20
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      21     0  args   [Ljava/lang/String;

  public void method1();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=1
         0: iconst_1
         1: istore_1
         2: iload_1
         3: iinc          1, 1
         6: istore_2
         7: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
        10: iload_2
        11: invokevirtual #7                  // Method java/io/PrintStream.println:(I)V
        14: return
      LineNumberTable:
        line 10: 0
        line 11: 2
        line 12: 7
        line 13: 14
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      15     0  this   Lcn/itcast/jvm/Test2;
            2      13     1     i   I
            7       8     2     a   I

  public void method2();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=1
         0: iconst_1
         1: istore_1
         2: iinc          1, 1
         5: iload_1
         6: istore_2
         7: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
        10: iload_2
        11: invokevirtual #7                  // Method java/io/PrintStream.println:(I)V
        14: return
      LineNumberTable:
        line 16: 0
        line 17: 2
        line 18: 7
        line 19: 14
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      15     0  this   Lcn/itcast/jvm/Test2;
            2      13     1     i   I
            7       8     2     a   I
}
SourceFile: "Test2.java"
对比

i++：

	0: iconst_1 //将数字1压入到操作栈 
	1: istore_1 //将数字1从操作栈弹出，压入到本地变量表中，下标为1 
	2: iload_1 //从本地变量表中获取下标为1的数据，压入到操作栈中 
	3: iinc 1, 1 // 将本地变量中的1，再+1 
	6: istore_2 // 将数字1从操作栈弹出，压入到本地变量表中，下标为2 
	7: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream; 
	10: iload_2 //从本地变量表中获取下标为2的数据，压入到操作栈中 
	11: invokevirtual #7 // Method java/io/PrintStream.println:(I)V 
	14: return

++i：

	0: iconst_1 //将数字1压入到操作栈 
	1: istore_1 //将数字1从操作栈弹出，压入到本地变量表中，下标为1 
	2: iinc 1, 1// 将本地变量中的1，再+1 
	5: iload_1 //从本地变量表中获取下标为1的数据（2），压入到操作栈中 
	6: istore_2 //将数字2从操作栈弹出，压入到本地变量表中，下标为2 
	7: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream; 
	10: iload_2 //从本地变量表中获取下标为2的数据（2），压入到操作栈中 
	11: invokevirtual #7 // Method java/io/PrintStream.println:(I)V 
	14: return

区别：

  • i++

    • 只是在本地变量中对数字做了相加，并没有将数据压入到操作栈
    • 将前面拿到的数字1，再次从操作栈中拿到，压入到本地变量中

  • ++i

    • 将本地变量中的数字做了相加，并且将数据压入到操作栈
    • 将操作栈中的数据，再次压入到本地变量中

小结：可以通过查看字节码的方式对代码的底层做研究，探究其原理。

字符串拼接

字符串的拼接在开发过程中使用是非常频繁的，常用的方式有三种：

  • +号拼接： str+"456"
  • StringBuilder拼接
  • StringBuffer拼接

StringBuffer是保证线程安全的，效率是比较低的，我们更多的是使用场景是不会涉及到 线程安全的问题的，所以更多的时候会选择StringBuilder，效率会高一些。

那么，问题来了，StringBuilder和“+”号拼接，哪个效率高呢？接下来我们通过字节码的 方式进行探究。
首先，编写个示例：

public class Test3 {
    public static void main(String[] args) {
        new Test3().m1();
        new Test3().m2();
    }

    public void m1() {
        String s1 = "123";
        String s2 = "456";
        String s3 = s1 + s2;
        System.out.println(s3);
    }

    public void m2() {
        String s1 = "123";
        String s2 = "456";
        StringBuilder sb = new StringBuilder();
        sb.append(s1);
        sb.append(s2);
        String s3 = sb.toString();
        System.out.println(s3);
    }
}

查看Test3.class的字节码

Classfile /C:/mydocuments/IdeaProjects/basic-code/out/production/day08/cn/itcast/jvm/Test3.class
  Last modified 2019-9-6; size 1112 bytes
  MD5 checksum 967c14ff6ffde5d3d0794d996b4323b8
  Compiled from "Test3.java"
public class cn.itcast.jvm.Test3
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #14.#36        // java/lang/Object."<init>":()V
   #2 = Class              #37            // cn/itcast/jvm/Test3
   #3 = Methodref          #2.#36         // cn/itcast/jvm/Test3."<init>":()V
   #4 = Methodref          #2.#38         // cn/itcast/jvm/Test3.m1:()V
   #5 = Methodref          #2.#39         // cn/itcast/jvm/Test3.m2:()V
   #6 = String             #40            // 123
   #7 = String             #41            // 456
   #8 = Class              #42            // java/lang/StringBuilder
   #9 = Methodref          #8.#36         // java/lang/StringBuilder."<init>":()V
  #10 = Methodref          #8.#43         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #11 = Methodref          #8.#44         // java/lang/StringBuilder.toString:()Ljava/lang/String;
  #12 = Fieldref           #45.#46        // java/lang/System.out:Ljava/io/PrintStream;
  #13 = Methodref          #47.#48        // java/io/PrintStream.println:(Ljava/lang/String;)V
  #14 = Class              #49            // java/lang/Object
  #15 = Utf8               <init>
  #16 = Utf8               ()V
  #17 = Utf8               Code
  #18 = Utf8               LineNumberTable
  #19 = Utf8               LocalVariableTable
  #20 = Utf8               this
  #21 = Utf8               Lcn/itcast/jvm/Test3;
  #22 = Utf8               main
  #23 = Utf8               ([Ljava/lang/String;)V
  #24 = Utf8               args
  #25 = Utf8               [Ljava/lang/String;
  #26 = Utf8               m1
  #27 = Utf8               s1
  #28 = Utf8               Ljava/lang/String;
  #29 = Utf8               s2
  #30 = Utf8               s3
  #31 = Utf8               m2
  #32 = Utf8               sb
  #33 = Utf8               Ljava/lang/StringBuilder;
  #34 = Utf8               SourceFile
  #35 = Utf8               Test3.java
  #36 = NameAndType        #15:#16        // "<init>":()V
  #37 = Utf8               cn/itcast/jvm/Test3
  #38 = NameAndType        #26:#16        // m1:()V
  #39 = NameAndType        #31:#16        // m2:()V
  #40 = Utf8               123
  #41 = Utf8               456
  #42 = Utf8               java/lang/StringBuilder
  #43 = NameAndType        #50:#51        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #44 = NameAndType        #52:#53        // toString:()Ljava/lang/String;
  #45 = Class              #54            // java/lang/System
  #46 = NameAndType        #55:#56        // out:Ljava/io/PrintStream;
  #47 = Class              #57            // java/io/PrintStream
  #48 = NameAndType        #58:#59        // println:(Ljava/lang/String;)V
  #49 = Utf8               java/lang/Object
  #50 = Utf8               append
  #51 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #52 = Utf8               toString
  #53 = Utf8               ()Ljava/lang/String;
  #54 = Utf8               java/lang/System
  #55 = Utf8               out
  #56 = Utf8               Ljava/io/PrintStream;
  #57 = Utf8               java/io/PrintStream
  #58 = Utf8               println
  #59 = Utf8               (Ljava/lang/String;)V
{
  public cn.itcast.jvm.Test3();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcn/itcast/jvm/Test3;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: new           #2                  // class cn/itcast/jvm/Test3
         3: dup
         4: invokespecial #3                  // Method "<init>":()V
         7: invokevirtual #4                  // Method m1:()V
        10: new           #2                  // class cn/itcast/jvm/Test3
        13: dup
        14: invokespecial #3                  // Method "<init>":()V
        17: invokevirtual #5                  // Method m2:()V
        20: return
      LineNumberTable:
        line 5: 0
        line 6: 10
        line 7: 20
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      21     0  args   [Ljava/lang/String;

  public void m1();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=4, args_size=1
         0: ldc           #6                  // String 123
         2: astore_1
         3: ldc           #7                  // String 456
         5: astore_2
         6: new           #8                  // class java/lang/StringBuilder
         9: dup
        10: invokespecial #9                  // Method java/lang/StringBuilder."<init>":()V
        13: aload_1
        14: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        17: aload_2
        18: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        21: invokevirtual #11                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        24: astore_3
        25: getstatic     #12                 // Field java/lang/System.out:Ljava/io/PrintStream;
        28: aload_3
        29: invokevirtual #13                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        32: return
      LineNumberTable:
        line 10: 0
        line 11: 3
        line 12: 6
        line 13: 25
        line 14: 32
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      33     0  this   Lcn/itcast/jvm/Test3;
            3      30     1    s1   Ljava/lang/String;
            6      27     2    s2   Ljava/lang/String;
           25       8     3    s3   Ljava/lang/String;

  public void m2();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=5, args_size=1
         0: ldc           #6                  // String 123
         2: astore_1
         3: ldc           #7                  // String 456
         5: astore_2
         6: new           #8                  // class java/lang/StringBuilder
         9: dup
        10: invokespecial #9                  // Method java/lang/StringBuilder."<init>":()V
        13: astore_3
        14: aload_3
        15: aload_1
        16: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        19: pop
        20: aload_3
        21: aload_2
        22: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        25: pop
        26: aload_3
        27: invokevirtual #11                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        30: astore        4
        32: getstatic     #12                 // Field java/lang/System.out:Ljava/io/PrintStream;
        35: aload         4
        37: invokevirtual #13                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        40: return
      LineNumberTable:
        line 17: 0
        line 18: 3
        line 19: 6
        line 20: 14
        line 21: 20
        line 22: 26
        line 23: 32
        line 24: 40
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      41     0  this   Lcn/itcast/jvm/Test3;
            3      38     1    s1   Ljava/lang/String;
            6      35     2    s2   Ljava/lang/String;
           14      27     3    sb   Ljava/lang/StringBuilder;
           32       9     4    s3   Ljava/lang/String;
}
SourceFile: "Test3.java"

从解字节码中可以看出，m1()方法源码中是使用+号拼接，但是在字节码中也被编译成了 StringBuilder方式。

所以，可以得出结论，字符串拼接，+号和StringBuilder是相等的，效率一样。

接下来，我们再看一个案例：

public class Test4 {
    public static void main(String[] args) {
        new Test4().m1();
        new Test4().m2();
    }

    public void m1() {
        String str = "";
        for (int i = 0; i < 5; i++) {
            str = str + i;
        }
        System.out.println(str);
    }

    public void m2() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 5; i++) {
            sb.append(i);
        }
        System.out.println(sb.toString());
    }
}

m1()与m2()哪个方法的效率最高？
依然是通过字节码的方式进行探究。

Classfile /C:/mydocuments/IdeaProjects/basic-code/out/production/day08/cn/itcast/jvm/Test4.class
  Last modified 2019-9-6; size 1190 bytes
  MD5 checksum 313efd78f79d69892504287eeccbd6f0
  Compiled from "Test4.java"
public class cn.itcast.jvm.Test4
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #14.#39        // java/lang/Object."<init>":()V
   #2 = Class              #40            // cn/itcast/jvm/Test4
   #3 = Methodref          #2.#39         // cn/itcast/jvm/Test4."<init>":()V
   #4 = Methodref          #2.#41         // cn/itcast/jvm/Test4.m1:()V
   #5 = Methodref          #2.#42         // cn/itcast/jvm/Test4.m2:()V
   #6 = String             #43            //
   #7 = Class              #44            // java/lang/StringBuilder
   #8 = Methodref          #7.#39         // java/lang/StringBuilder."<init>":()V
   #9 = Methodref          #7.#45         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #10 = Methodref          #7.#46         // java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
  #11 = Methodref          #7.#47         // java/lang/StringBuilder.toString:()Ljava/lang/String;
  #12 = Fieldref           #48.#49        // java/lang/System.out:Ljava/io/PrintStream;
  #13 = Methodref          #50.#51        // java/io/PrintStream.println:(Ljava/lang/String;)V
  #14 = Class              #52            // java/lang/Object
  #15 = Utf8               <init>
  #16 = Utf8               ()V
  #17 = Utf8               Code
  #18 = Utf8               LineNumberTable
  #19 = Utf8               LocalVariableTable
  #20 = Utf8               this
  #21 = Utf8               Lcn/itcast/jvm/Test4;
  #22 = Utf8               main
  #23 = Utf8               ([Ljava/lang/String;)V
  #24 = Utf8               args
  #25 = Utf8               [Ljava/lang/String;
  #26 = Utf8               m1
  #27 = Utf8               i
  #28 = Utf8               I
  #29 = Utf8               str
  #30 = Utf8               Ljava/lang/String;
  #31 = Utf8               StackMapTable
  #32 = Class              #53            // java/lang/String
  #33 = Utf8               m2
  #34 = Utf8               sb
  #35 = Utf8               Ljava/lang/StringBuilder;
  #36 = Class              #44            // java/lang/StringBuilder
  #37 = Utf8               SourceFile
  #38 = Utf8               Test4.java
  #39 = NameAndType        #15:#16        // "<init>":()V
  #40 = Utf8               cn/itcast/jvm/Test4
  #41 = NameAndType        #26:#16        // m1:()V
  #42 = NameAndType        #33:#16        // m2:()V
  #43 = Utf8
  #44 = Utf8               java/lang/StringBuilder
  #45 = NameAndType        #54:#55        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #46 = NameAndType        #54:#56        // append:(I)Ljava/lang/StringBuilder;
  #47 = NameAndType        #57:#58        // toString:()Ljava/lang/String;
  #48 = Class              #59            // java/lang/System
  #49 = NameAndType        #60:#61        // out:Ljava/io/PrintStream;
  #50 = Class              #62            // java/io/PrintStream
  #51 = NameAndType        #63:#64        // println:(Ljava/lang/String;)V
  #52 = Utf8               java/lang/Object
  #53 = Utf8               java/lang/String
  #54 = Utf8               append
  #55 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #56 = Utf8               (I)Ljava/lang/StringBuilder;
  #57 = Utf8               toString
  #58 = Utf8               ()Ljava/lang/String;
  #59 = Utf8               java/lang/System
  #60 = Utf8               out
  #61 = Utf8               Ljava/io/PrintStream;
  #62 = Utf8               java/io/PrintStream
  #63 = Utf8               println
  #64 = Utf8               (Ljava/lang/String;)V
{
  public cn.itcast.jvm.Test4();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcn/itcast/jvm/Test4;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: new           #2                  // class cn/itcast/jvm/Test4
         3: dup
         4: invokespecial #3                  // Method "<init>":()V
         7: invokevirtual #4                  // Method m1:()V
        10: new           #2                  // class cn/itcast/jvm/Test4
        13: dup
        14: invokespecial #3                  // Method "<init>":()V
        17: invokevirtual #5                  // Method m2:()V
        20: return
      LineNumberTable:
        line 5: 0
        line 6: 10
        line 7: 20
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      21     0  args   [Ljava/lang/String;

  public void m1();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=1
         0: ldc           #6                  // String
         2: astore_1
         3: iconst_0
         4: istore_2
         5: iload_2
         6: iconst_5
         7: if_icmpge     35
        10: new           #7                  // class java/lang/StringBuilder
        13: dup
        14: invokespecial #8                  // Method java/lang/StringBuilder."<init>":()V
        17: aload_1
        18: invokevirtual #9                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        21: iload_2
        22: invokevirtual #10                 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
        25: invokevirtual #11                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        28: astore_1
        29: iinc          2, 1
        32: goto          5
        35: getstatic     #12                 // Field java/lang/System.out:Ljava/io/PrintStream;
        38: aload_1
        39: invokevirtual #13                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        42: return
      LineNumberTable:
        line 10: 0
        line 11: 3
        line 12: 10
        line 11: 29
        line 14: 35
        line 15: 42
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            5      30     2     i   I
            0      43     0  this   Lcn/itcast/jvm/Test4;
            3      40     1   str   Ljava/lang/String;
      StackMapTable: number_of_entries = 2
        frame_type = 253 /* append */
          offset_delta = 5
          locals = [ class java/lang/String, int ]
        frame_type = 250 /* chop */
          offset_delta = 29

  public void m2();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=1
         0: new           #7                  // class java/lang/StringBuilder
         3: dup
         4: invokespecial #8                  // Method java/lang/StringBuilder."<init>":()V
         7: astore_1
         8: iconst_0
         9: istore_2
        10: iload_2
        11: iconst_5
        12: if_icmpge     27
        15: aload_1
        16: iload_2
        17: invokevirtual #10                 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
        20: pop
        21: iinc          2, 1
        24: goto          10
        27: getstatic     #12                 // Field java/lang/System.out:Ljava/io/PrintStream;
        30: aload_1
        31: invokevirtual #11                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        34: invokevirtual #13                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        37: return
      LineNumberTable:
        line 18: 0
        line 19: 8
        line 20: 15
        line 19: 21
        line 22: 27
        line 23: 37
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
           10      17     2     i   I
            0      38     0  this   Lcn/itcast/jvm/Test4;
            8      30     1    sb   Ljava/lang/StringBuilder;
      StackMapTable: number_of_entries = 2
        frame_type = 253 /* append */
          offset_delta = 10
          locals = [ class java/lang/StringBuilder, int ]
        frame_type = 250 /* chop */
          offset_delta = 16
}
SourceFile: "Test4.java"

可以看到，m1()方法中的循环体内，每一次循环都会创建StringBuilder对象，效率低于 m2()方法。

小结

使用字节码的方式可以很好查看代码底层的执行，从而可以看出哪些实现效率高，哪些 实现效率低。可以更好的对我们的代码做优化。让程序执行效率更高。

9.冄2.7.號
关注
专栏目录
Java从入门到精通 第九章 数字处理类
zhengzaifeidelushang的博客
12-10 220
Java从入门到精通 第九章 数字处理类 在解决实际问题中，对数字的处理是非常普遍的，如数学问题、随机问题、商业货币问题、科学计数问题等。Java提供了处理相关问题的类，包括DecimalFormat类(用于格式化数字)、Math类（为各种数学计数提供了工具方法）、Random类(为Java处理随机数问题提供了各种方法)、BigInteger类与BigDecimal类(为所有大数字的处理提供了相应的数学运算操作方法)。 一、数字格式化 在Java中没有格式化的数据遵循以下原则： 如果数据绝对值大于0.00
Java2.5的
02-16
Java2.5的
史上最全的Java代码规范
weixin_39282590的博客
12-28 6377
       不管学习什么，头脑里要有一定的规范，这样才能形成自己逻辑，命名好自己的代码，也是不但为了自己，而且为了别人更好的定位你这个人的人品，以及个人的能力。没有学习好的同学，跟着我的脚步，学习Java的命名规范，哦，不仅仅是Java,用到技术，都可以这样命名，来提高你对代码的观赏性。 本Java代码规范以SUN的标准Java代码规范为基础，为适应我们公司的实际需要，可能会做一些修改。本文档...
jvm--字节码浅析
hijunmeng的专栏
07-19 676
上图就是字节码文件的结构，是从官方截取而来的，u来表示一个无符号字节，u1表示1个字节，u2表示2个字节，u4表示4个字节）那么方法有什么属性呢，方法抛出的异常可以算一个，方法的参数名也是，方法里的指令也是一个属性（即方法体）这个结构总体看起来还是很清晰的，解析的时候也只要跟随这个总体结构一步一步深入下去即可。下面我们就来解释下这些结构（下文中所说的位置和索引其实是同个意思）方法的访问标识可以有如下。..............................
科普文：Java基础系列之【java框架基础：性能优化-JVM字节码】
为无为，事无事，味无味。
08-13 774
前面我们通过tomcat本身的参数以及jvm的参数对tomcat做了优化，其实要想将应用程 序跑的更快、效率更高，除了对tomcat以及jvm优化外，应用程序代码本身如果写的效率不高的，那么也是不行的，所以，对于程序本身的优化也就很重要了。所以，可以得出结论，字符串拼接，+号和StringBuilder是相等的，效率一样。StringBuffer是保证线程安全的，效率是比较低的，我们更多的是使用场景是不会涉及到线程安全的问题的，所以更多的时候会选择StringBuilder，效率会高一些。
jvm之字节码指令集解读（上）
一个菜鸡的博客
04-07 482
Java字节码指令集是一组计算机指令，用于在Java虚拟机上执行Java程序。这些指令编码了操作码、操作数和控制信息，可以用于执行Java语言程序的所有操作，如变量赋值、方法调用、控制流与异常处理等。Java字节码指令集可以直接被Java虚拟机读取和解释，并且保证了Java程序在不同平台上的可移植性。
科普文：Java基础系列之【JVM 字节码操作 ASM 框架概叙】
为无为，事无事，味无味。
08-11 706
ASM 是一款直接操作字节码（即 class 文件）的框架，可以都已生成好的字节码进行改动或者生成。类似框架有 javassist 相对 ASM 简单许多。
JVM基础：字节码文件详解①
siaok的博客
10-28 1379
👉概述。
【JVM基础篇】字节码文件详解
记录一名在读研究生的学习笔记、感悟、开发产物
05-10 1254
介绍字节码文件的打开方式、组成部分、常用工具、Arthas工具的简单使用
java字节码.docx
04-12
Java 字节码解读 Java 字节码是一种中间形式的代码，它是 Java 源代码编译后的结果。Java 字节码是平台独立的，可以在任何支持 Java 的设备上运行。Java 字节码的结构主要包括魔数、主版本号、次版本号、常量池、...
从一个class文件深入理解Java字节码结构
11-15
Java程序在执行时，首先需要通过Java编译器将源代码（.java文件）编译成二进制的字节码文件（.class文件），这些字节码由Java虚拟机（JVM）解析并执行。深入理解字节码结构有助于我们了解Java程序的运行机制，优化...
java之解读class字节码文件，打开jvm大门
知道的越多，不知道的越多
05-12 1489
亲爱的java程序员:一定，一定，一定要学会解读class字节码文件!!! 1.JVM体系结构以及class文件位置： 2.编写程序、编译、打开class文件： 3.怎么解读class文件中十六进制信息？ 3.1.初步理解解读class文件组成图[官方图]： 3.2.继续解读代码示例class文件内容【难点】： 3.2.1 解读注意问题： 4.解读文件下载： 5.使用官方命令反编译class文件：哦！原来是这样的！ 6.本文的案例对应的`虚拟机指令解读`请见笔者文章：
【Java基础知识 43】Java 字节码，javap命令，解读字节码清单
学Java，找哪吒
07-12 638
由于不同的操作系统和硬件架构的指令集和寄存器等硬件层次结构不同，为了实现Java程序的跨平台性，JVM需要在不同的平台上实现一套统一的指令集和操作数。Java字节码（Java bytecode）是Java语言的一种特殊格式，是Java虚拟机（JVM）能够识别和执行的一组指令。同时，由于字节码是经过编译的，因此它的执行速度可以比解释执行Java源代码更快。Java字节码是Java语言实现跨平台性的关键之一，它是Java编译器生成的中间代码，可以被JVM加载、解释和执行。65001代表编码格式为utf-8。
Java字节码解读
走过路过不要错过
10-06 944
Java最重要的一个机制就是虚拟机JVM，通过执行编译好的字节码.class文件，可以实现跨平台的可移植性，那么小伙伴们会不会好奇字节码文件是怎样的，它是怎么工作的？参考来源，为了便于回顾，特此按自己思路重头来一遍，接下来我们就一起来解读一下字节码文件，前方高能，大脑请提前清空。 1. 前期准备 1.1 首先编写一个测试程序，简单地在main方法中声明一个Integer包装类型变量i和一个基本类型int类型变量n，代码如下。 public class EnTest { public s.
【JVM】如何解读字节码文件
weixin_45880263的博客
04-14 1157
JDK中的字节码文件 一、什么是字节码文件 众所周知，java是一种跨平台的语言，实现java跨平台的底层逻辑在于其中间编译产物——【字节码文件】。实际上，与其说java是跨平台的语言，不如说jvm是跨语言的平台。因为jvm就是基于解读字节码文件来运行的，任何可以翻译成字节码文件的语言都可以通过jvm实现跨平台。可见字节码文件的重要性，下面就来具体介绍字节码文件。 课外延申 jdk每新出一个版本就对应两套规范，一个是java语法规范，一个是jvm规范。原因就在于其它语言也可以基于jvm运行。 1、远
滑板开关端子折弯机_三维3D设计图纸.zip
10-05
滑板开关端子折弯机_三维3D设计图纸.zip
基于Vue框架的毕业生离校管理系统设计源码
最新发布
10-05
本项目为基于Vue框架开发的毕业生离校管理系统设计源码，包含322个文件，涵盖147个Vue组件、95个JavaScript脚本、46个SVG图形、9个SCSS样式表、3个Handlebars模板、2个YAML配置、2个Markdown文件、2个JSON数据、2个PNG图片和2个CSS样式文件。系统采用Vue、JavaScript、CSS和HTML等多种编程语言和技术构建，旨在实现毕业生的离校管理功能。
基于SpringBoot和Vue的桂林旅游景点导游平台设计源码
10-05
本项目是一款基于SpringBoot和Vue构建的桂林旅游景点导游平台源码，包含798个文件，涵盖了162个SVG图形、152个JavaScript文件、107个Java文件、79个GIF动画、50个PNG图片、48个JPG图像、46个Vue组件、44个CSS样式表、44个HTML模板、16个地图文件。该平台利用JavaScript、Java、Vue、CSS和HTML等多种语言和技术，为用户提供全面的旅游导览服务。
Java字节码解析：深入理解字节码结构
"这是一份关于Java字节码的解读文档，旨在帮助读者理解字节码的内部结构和相关信息。文档中详细列出了字节码的相关组成部分，包括魔数、版本号、常量池等，并列举了常量池中的各项条目，如类名、方法名、字段名等，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

9.冄2.7.號

你的鼓励将是我创作的巨大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值