虚拟机-通过字节码分析面试题

最新推荐文章于 2021-06-30 12:20:00 发布
最新推荐文章于 2021-06-30 12:20:00 发布
阅读量482 收藏
点赞数 1
分类专栏： java虚拟机 文章标签： 虚拟机 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fffffcccccv/article/details/79823571
版权

在面试的时候，我们经常问碰到字符串相关的问题，问一段代码会产生几个对象，今天我们选取几个典型的例子，通过字节码以及字符串常量池来简单分析一下。

问题一

public class Test1 {

    public static void main(String[] args) {
        String s = "a"+"b"+"c";
    }

}

首先编译java文件，生成class文件

javac Test1.java

然后生成字节码

javap -c Test1.class > log1.txt
javap -verbose Test1.class > log2.txt

上面两句，第一句只是简单的打印出字节码，第二句打印出的信息更为详细，我们为了看到常量池，所以使用第二句，我这里得到的结果如下


Classfile /Users/aaron/work/java/src/com/jvm/Test1.class
  Last modified 2018-4-4; size 271 bytes
  MD5 checksum 1a7c3e14f23649c4fba890dc20bd1683
  Compiled from "Test1.java"
public class Test1
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #4.#13         // java/lang/Object."<init>":()V
   #2 = String             #14            // abc
   #3 = Class              #15            // Test1
   #4 = Class              #16            // java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Utf8               Code
   #8 = Utf8               LineNumberTable
   #9 = Utf8               main
  #10 = Utf8               ([Ljava/lang/String;)V
  #11 = Utf8               SourceFile
  #12 = Utf8               Test1.java
  #13 = NameAndType        #5:#6          // "<init>":()V
  #14 = Utf8               abc
  #15 = Utf8               Test1
  #16 = Utf8               java/lang/Object
{
  public 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 2: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=2, args_size=1
         0: ldc           #2                  // String abc
         2: astore_1
         3: return
      LineNumberTable:
        line 5: 0
        line 6: 3
}
SourceFile: "Test1.java"

这里 #1到#16代表了常量池里的对象，可以看出只有一个String对象abc

我们再看下main方法相关的字节码，首先

0: ldc           #2                  // String abc

将常量加载到操作数栈，可以看出，这里的常量直接就是abc了，那”a”+”b”+”c”是什么时候变成abc的呢？

首先，我们简要的介绍下javac编译的流程

1、解析与填充符号表
    1) 词法、语法分析
    2) 填充符号表
2、注解处理器
3、语义分析与字节码生成
    1) 标注检查 
    2) 数据及控制流分析 
    3) 解语法糖 
    4) 字节码生成

那么，在标注检查的过程中，有一个关键的操作叫常量折叠，所以这边的”a”+”b”+”c”直接折叠成abc了(1+2也是会折叠成3的)。
常量加载到操作栈后，调用 astore_1 将栈顶元素也就是abc指向本地变量s就return了，所以很明显这里只创建了一个对象。

问题二

package com.jvm;

public class Test2 {
    public static void main(String[] args) {
        String s = new String("abc");
    }
}

生成的字节码如下

Classfile /Users/aaron/work/java/src/com/jvm/Test2.class
  Last modified 2018-4-4; size 342 bytes
  MD5 checksum 03699a3397f3795430f6d40608b5f2ad
  Compiled from "Test2.java"
public class com.jvm.Test2
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #6.#15         // java/lang/Object."<init>":()V
   #2 = Class              #16            // java/lang/String
   #3 = String             #17            // abc
   #4 = Methodref          #2.#18         // java/lang/String."<init>":(Ljava/lang/String;)V
   #5 = Class              #19            // com/jvm/Test2
   #6 = Class              #20            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               main
  #12 = Utf8               ([Ljava/lang/String;)V
  #13 = Utf8               SourceFile
  #14 = Utf8               Test2.java
  #15 = NameAndType        #7:#8          // "<init>":()V
  #16 = Utf8               java/lang/String
  #17 = Utf8               abc
  #18 = NameAndType        #7:#21         // "<init>":(Ljava/lang/String;)V
  #19 = Utf8               com/jvm/Test2
  #20 = Utf8               java/lang/Object
  #21 = Utf8               (Ljava/lang/String;)V
{
  public com.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

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=2, args_size=1
         0: new           #2                  // class java/lang/String
         3: dup
         4: ldc           #3                  // String abc
         6: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
         9: astore_1
        10: return
      LineNumberTable:
        line 5: 0
        line 6: 10
}
SourceFile: "Test2.java"

可以看出，#2是一个Class对象，类型是String，也就是通过new String()生成的，而 #3则是一个String对象，值是abc，记住，当我们第一次引用一个字符串时，会成常量池中生成一个String对象，如果下次用到相同的字符串，则会引用之前生成的对象。

看完常量池，我们继续分析字节码

0: new           #2                  // class java/lang/String

首先，创建一个String对象，并将其引用放到栈顶

3: dup

然后，复制该引用，此时栈上有两个对象引用

4: ldc           #3                  // String abc

接着，将值abc复制到栈顶，这是String()初始化需要的参数

6: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V

当参数准备就绪，就会调用String的init方法，这是对象的默认初始化方法，生成字节码时会自动帮我们生成。
这里对象初始化有两个参数，第一个参数是String引用，也就是我们常用的this对象，第二个参数则是值abc了。
由于两个引用指向同一个对象，那么对象初始化完成后，第一个引用也就有值了。

9: astore_1

最后，将第一个引用指向的对象赋值给变量s，并返回，分析结束。所以，这里创建了两个对象。

问题三

package com.jvm;

public class Test3 {

    public static void main(String[] args) {
        String a = "a";
        String b="c";
        String c="a";
        String s = a+b+c;
    }

}

字节码如下

Classfile /Users/aaron/work/java/src/com/jvm/Test3.class
  Last modified 2018-4-4; size 471 bytes
  MD5 checksum 3bb78402acc3a2e607a0d50705125671
  Compiled from "Test3.java"
public class com.jvm.Test3
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #9.#18         // java/lang/Object."<init>":()V
   #2 = String             #19            // a
   #3 = String             #20            // c
   #4 = Class              #21            // java/lang/StringBuilder
   #5 = Methodref          #4.#18         // java/lang/StringBuilder."<init>":()V
   #6 = Methodref          #4.#22         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   #7 = Methodref          #4.#23         // java/lang/StringBuilder.toString:()Ljava/lang/String;
   #8 = Class              #24            // com/jvm/Test3
   #9 = Class              #25            // java/lang/Object
  #10 = Utf8               <init>
  #11 = Utf8               ()V
  #12 = Utf8               Code
  #13 = Utf8               LineNumberTable
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               SourceFile
  #17 = Utf8               Test3.java
  #18 = NameAndType        #10:#11        // "<init>":()V
  #19 = Utf8               a
  #20 = Utf8               c
  #21 = Utf8               java/lang/StringBuilder
  #22 = NameAndType        #26:#27        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #23 = NameAndType        #28:#29        // toString:()Ljava/lang/String;
  #24 = Utf8               com/jvm/Test3
  #25 = Utf8               java/lang/Object
  #26 = Utf8               append
  #27 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #28 = Utf8               toString
  #29 = Utf8               ()Ljava/lang/String;
{
  public com.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

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=5, args_size=1
         0: ldc           #2                  // String a
         2: astore_1
         3: ldc           #3                  // String c
         5: astore_2
         6: ldc           #2                  // String a
         8: astore_3
         9: new           #4                  // class java/lang/StringBuilder
        12: dup
        13: invokespecial #5                  // Method java/lang/StringBuilder."<init>":()V
        16: aload_1
        17: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        20: aload_2
        21: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        24: aload_3
        25: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        28: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        31: astore        4
        33: return
      LineNumberTable:
        line 6: 0
        line 7: 3
        line 8: 6
        line 9: 9
        line 10: 33
}
SourceFile: "Test3.java"

可见，#2 #3 #4 分别代表了字符串a、字符串c和对象StringBuilder，继续品尝字节码

         0: ldc           #2                  // String a
         2: astore_1
         3: ldc           #3                  // String c
         5: astore_2
         6: ldc           #2                  // String a
         8: astore_3

首先，将值分别赋给对应的变量，可以看出，相同的字符串a只会在常量池中存在一份

         9: new           #4                  // class java/lang/StringBuilder
        12: dup

同样创建两个引用，一个用于后续操作，一个用于在新的init栈桢中使用

        13: invokespecial #5                  // Method java/lang/StringBuilder."<init>":()V
        16: aload_1
        17: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        20: aload_2
        21: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        24: aload_3
        25: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        28: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;

初始化后，将三个变量的值依次加载到栈顶，并调用append方法进行拼接。看到这里很明显了，对于String对象的拼接操作，在字节码层面会默认转换成
StringBuilder操作，可以节省String对象的分配。添加完成后，通过toString转换成String对象。

        31: astore        4
        33: return

最后，显然又是赋值给变量s然后返回的操作了。所以，大家也能看出，这里创建了三个对象，字符串a、c和StringBuilder喽。

由于学习虚拟机时间不久，分析的过程可能有些纰漏，还请各位看官指正。

雪未央
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2024年java面试题-jvm之java虚拟机面试题
04-20
### 2024年Java面试题：JVM之Java虚拟机面试题 #### Java内存模型及基础知识 **1. Java代码如何被计算机识别** Java程序最初由开发人员使用Java语法编写，这些代码人类可读但计算机无法直接理解。为了使计算机...
2017-2020字节跳动Android面试历年真题解析_04cba.pdf
09-02
对于网络面试题，你需要熟悉TCP/IP协议栈、HTTP/HTTPS协议、DNS解析过程、网络状态码以及负载均衡等概念。操作系统方面，了解进程与线程的区别、内存管理机制、磁盘I/O等。数据存储方面，要理解数据库的ACID特性，...
JVM面试题以及字节码讲解
麦田里的守望者
04-19 272
0 前言 关于java字节码指令的含义，可以参考这篇博客：Java字节码指令含义解释与指令查询 1 try…catch…finally 1.1 catch 1.1.1 catch单个异常 查看相应的java代码： public class FinallyDemo { public static void main(String[] args) { int i = 10; ...
字节码角度分析面试题 —— i++、++i 傻傻分不清楚
韭菜鲜肉大馄饨的专栏
06-16 325
字节码角度分析面试题 —— i++、++i 傻傻分不清楚一、什么都憋说，先看题二、i++二、++i三、看一道 xue 微难一点的题目四、小结五、最后一题六、回答 一、什么都憋说，先看题 public class Test { public static void foo() { int i = 0; for (int j = 0; j < 50; j+...
深入理解虚拟机之虚拟机字节码执行引擎
weixin_34410662的博客
05-12 176
1 概述 执行引擎是java虚拟机最核心的组成部件之一。虚拟机的执行引擎由自己实现，所以可以自行定制指令集与执行引擎的结构体系，并且能够执行那些不被硬件直接支持的指令集格式。 所有的Java虚拟机的执行引擎都是一致的：输入的是字节码文件，处理过程是字节码解析的等效过程，输出的是执行结果。本节将主要从概念模型的角度来讲解虚拟机的方法调用和字节码执行。 2 运行时栈帧结构 栈帧（Stack Frame...
深入解析一道关于String面试题（字节码/ByteCode）
lyy9902的博客
08-28 318
这是一个比较常见的关于字符串的面试题，如下： public static void main(String[] args) { String s1 = "Hello"; String s2 = "Hello"; String s3 = "Hel" + "lo"; String s4 = "Hel" + new String("lo"); String s5 = new String("Hello");
Java常见面试题 -- 什么是字节码？采用字节码的好处是什么？
weixin_46481307的博客
06-30 382
Java中的编译器和解释器： Java中引入了虚拟机的概念，即在机器和编译程序之间加入了一层抽象的虚拟机的机器，这台虚拟的机器在任何平台上都提供给编译程序一个共同的接口 。 编译程序只需要面向虚拟机，生成虚拟机能够理解的代码，然后由解析器来将虚拟机代码转换位特定系统的机器码执行。在Java中，这种虚拟机理解的代码叫字节码（即扩展名为.class的文件，它不面向任何特定的处理器，只面向虚拟机） 每一种平台的解析器都是不同的，但是实现的虚拟机是相同的。Java源程序经过编译器后变成字节码，字节码由虚拟机解释执行
Java虚拟机（JVM）面试题（总结最全面的面试题！！！）
12-21
JVM通过解释器或即时编译器（JIT）将字节码转换为特定硬件平台的机器码，从而实现了跨平台。 JVM主要由以下几个部分组成： 1. 类加载器（Class Loader）：负责加载运行所需的类文件，遵循双亲委派模型，从...
面试题-全网最新的Java面试题及答案
最新发布
01-31
### Java面试题知识点详解 #### 一、面向对象与面向过程的区别 1. **面向过程**： - **优点**：性能较高。因为无需实例化类，减少了内存占用和CPU开销，尤其适合对性能要求极高的场景，如单片机、嵌入式开发、...
面试题_字节码是什么？采用字节码有哪些好处呢？
qq_41494557的博客
04-29 388
字节码是什么？采用字节码有哪些好处呢？ 一个Java程序的编译和运行是怎样的呢，简单的说就是： Java源程序(.java)>>>>>编译器 编译->>>>字节码(.class)>>>>JVM>>>>JVM中的解释器>>>>生成不同操作系统的机器码>>>>程序运行 开发人员编写代码保存在一个扩展名为.java的文件中，这个文件就是java的源文件 源文件编
Java面试题——什么是字节码
clearLB的博客
05-21 488
字节码 Java源代码经过虚拟机编译器编译后产生的文件（即.class文件），它是一种8位字节的二进制流文件，它不面向任何特定的处理器，只面向虚拟机，Java源文件被Java编译器编译之后，每个类（或者接口）都单独占据一个class文件 采用字节码的好处 Java语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保持了解释型语言可移植的特点，所以Java程序运行时比较高效 Java中的编译器和解释器 Java中引入了虚拟机的概念，==即在机器和编译程序之间加入了一层抽象的虚拟机器
java面试题jvm字节码的加载与卸载
weixin_30693683的博客
08-21 150
虚拟机把描述类的数据从class文件加载到内存，并对数据进行校验，转换分析和初始化，最终形成可以被虚拟节直接使用的JAVA类型，这就是虚拟机的类加载机制。 类从被加载到虚拟机内存到卸载出内存的生命周期包括：加载->连接(验证->准备->解析)->初始化->使用->卸载 初始化的5种情况： 1.使用new关键字实例化对象时，读取或设置一个类的静态字段，除被f...
面试官：说说你了解字节码指令和存储引擎？
小明的Java问道之路
08-22 527
字节码指令属于Class文件那个位置？常写的代码后的字节码你知道多少？Integer127的缓存能不能变？...不懂？一文带你深入浅出了解字节码指令和Java存储引擎
【笔记】深入理解 Java 虚拟机：虚拟机字节码执行引擎
albon arith
02-01 1441
虚拟机系列之 虚拟机字节码执行引擎
weixin_40824616的博客
12-26 147
虚拟机字节码执行引擎虚拟机字节码执行引擎1 概述2 运行时栈帧结构1）局部变量表2） 操作数栈3）动态连接4）方法返回地址5）附加信息3 方法调用1）解析2）分派3）单分派与多分派4 基于栈的字节码解释执行引擎 虚拟机字节码执行引擎 1 概述 在不同的虚拟机实现里面，执行引擎在执行java代码的时候可能有解释执行和编译执行两种选择，也可能两者兼备，甚至还可能包含几个不同级别的编译器执行引擎，但是从...
虚拟机字节码执行引擎
qq_32844875的博客
06-25 203
1 概述  代码编译是从本地机器码转变为字节码。 执行引擎是java虚拟机最核心的组成部分之一。 虚拟机是一个相对于物理机的概念。 物理机的执行引擎是直接建立在处理器、硬件、指令集和操作系统层面上，虚拟机的执行引擎则是由自己实现。 不同虚拟机实现里面，执行引擎在执行java代码的时候可能有解释执行和编译执行两种选择。 执行引擎都是一致的：过程都是输入的是字节码文件，处理过程是字节码解析的等效...
深入理解Java虚拟机-8虚拟机字节码执行引擎
SoundSlow的博客
10-19 343
参考：https://zhuanlan.zhihu.com/p/28468115 http://www.cnblogs.com/deman/p/5489895.html 8.1. * 概述：相对于物理机而言，Java虚拟机相当于一座架设在开发人员与物理机之间的“桥梁”。一端接受的是开发人员的字节码文件，另一端将字节码转化为物理机能够执行的机器码。这样，只要有java虚拟机存在的地方就可以使用虚
面试题byte
MimosaX的博客
06-07 264
//面试题 byte b1=3; byte b2=5; byte b; //强制类型转换 b=(byte)(b1+b2); /*byte类型的数据进行相加操作时会先转换为int类型, 而将int类型赋值给byte就会报错,强制类型转换错误*/ b=3+5; /*将常量进行...
Java虚拟机（JVM）面试题及垃圾回收机制详解
程序计数器主要负责存储当前线程执行的字节码指令地址，Java虚拟机栈用于存储方法执行时的局部变量表、操作数栈、动态链接以及方法出口等信息。当一个方法调用另一个方法时，会创建新的栈帧，并将其入栈。 Java堆是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值