JVM之StringTable

最新推荐文章于 2022-08-28 21:17:50 发布
最新推荐文章于 2022-08-28 21:17:50 发布
阅读量292 收藏
点赞数
分类专栏： java 文章标签： 字符串 java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40988088/article/details/114461449
版权

题目

    public static void main(String[] args) {
        String str1 = "a";
        String str2 = "b";
        String str3 = "ab";
        String str4 = "a" + "b";
        String str5 = new String("ab");
        String str6 = str5.intern();
        String str7 = str1 + str2;
        String str8 = str1 + "b";
        String str9 = new String("a") + new String("b");

        System.out.println("str3 == str4 :" + (str3 == str4));
        System.out.println("str3 == str5 :" + (str3 == str5));
        System.out.println("str3 == str6 :" + (str3 == str6));
        System.out.println("str3 == str7 :" + (str3 == str7));
        System.out.println("str3 == str8 :" + (str3 == str8));
        System.out.println("str3 == str9 :" + (str3 == str9));
    }

背景知识

要想解决以上的问题，需要一点JVM的知识，我们来看几个概念

1.常量池

java文件经过编译器编译后，生成class文件。class文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息是常量池，用来存放各种字面量和符号引用。可以使用javap -v命令反编译class文件，查看class文件中的常量池。下面只是截取了反编译结果的一部分，可以看到有一个Constant pool，就是常量池。

D:\workspace\target\classes\org\example\jvm\stringtable>javap -v StringTableTest.class
Classfile /D:/workspace/target/classes/org/example/jvm/stringtable/StringTableTest.class
  Last modified 2021-3-6; size 1583 bytes
  MD5 checksum dcee7d9fa800d5e955616c75868e56b6
  Compiled from "StringTableTest.java"
public class org.example.jvm.stringtable.StringTableTest
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #15.#43        // java/lang/Object."<init>":()V
   #2 = String             #44            // a
   #3 = String             #45            // b
   #4 = String             #46            // ab
   #5 = Class              #47            // java/lang/String
   #6 = Methodref          #5.#48         // java/lang/String."<init>":(Ljava/lang/String;)V
   #7 = Methodref          #5.#49         // java/lang/String.intern:()Ljava/lang/String;

2.方法区

 方法区，是各个线程共享的一块内存区域，用于存储已经被虚拟机加载的类信息、常量、静态变量等。所谓的方法区，是一个逻辑区域，不同的虚拟机厂商有不同的实现。以HotSpot为例，jdk1.6中方法区的实现是永久代，它位于jvm内存中；jdk1.8中方法区的实现是元空间（meta space）,他本身不属于jvm的内存。

3.运行时常量池

运行时常量池是方法区的一部分，class中的常量池在类加载后会存放至运行时常量池。

4.StringTable(串池)

jvm中用于存储字符串对象的一个容器，底层采用HashTable的数据结构实现。jdk1.8及以后，StringTable位于堆空间中，主要是堆中的垃圾回收比方法区较频繁，可以将不使用的字符串及时清理。那么什么样的字符串才会放进这个容器呢？总的来说有两种，第一种是运行时常量池中的字符串；第二种是String对象主动调用了intern()方法，将自己放进串池中。串池的存在，可以减少创建重复的字符串，节省内存空间。

这里需要说明的一点是，运行时常量池中的字符串，在被程序使用之前，仅仅是一个符号，并不是一个可以直接使用的String对象。当程序使用常量池的字符串时，会首先去串池中找是否存在该对象，如果存在，直接返回串池中的对象；如果不存在，创建一个字符串对象，将其放入串池，然后返回串池中的对象。

intern()方法，对于不同版本的jdk，其实现略微有所差异。jdk1.6及以前，调用该方法将字符串放进串池，如果串池没有值相同的字符串对象，则将原字符串复制一份，放进串池，并返回串池中的对象；如果有值相同的字符串对象，直接返回串池中的对象。jdk1.8略有不同，调用该方法将字符串放进串池，如果串池没有值相同的字符串对象，则将原字符串对象放进串池，并返回串池中的对象；如果有值相同的字符串对象，直接返回串池中的对象。

解题

有了上面的基础知识，我们来解答一下开始的题目。

1. String str3 = "ab"

String str3 = "ab"，编译以后会变成以下两条虚拟机指令。ldc #4，就是加载常量池#4位置的常量，也就是“ab”。astore_3，是将上一步得到的值存放至局部变量表的3号槽位。在程序运行时，会首先根据#4代表的真实地址，去运行时常量池找到对应的符号为“ab”。然后，以“ab”作为key，去串池中查找对应的字符串对象。显然不存在“ab”对象，这时会创建一个“ab”对象，放入串池中，最后返回这个对象。

         6: ldc           #4                  // String ab
         8: astore_3

2. String str4 = "a" + "b"

String str4 = "a" + "b"，虽然源代码是"a" + "b"，但是编译器会对这种两个常量相加的场景做优化，其结果就和str3完全一样。程序运行时，会首先根据#4代表的真实地址，去运行时常量池找到对应的符号为“ab”。然后，以“ab”作为key，去串池中查找对应的字符串对象，由于上一步已经在串池中存放了值为"ab"的对象，所以此时会直接返回串池中的"ab"对象。因此，str3 == str4。

        9: ldc           #4                  // String ab
        11: astore        4

3.String str5 = new String("ab")

String str5 = new String("ab")，根据编译后的虚拟机指令可以看出，这一行代码是在堆中创建了一个String对象，所以str5 != str3。

        13: new           #5                  // class java/lang/String
        16: dup
        17: ldc           #4                  // String ab
        19: invokespecial #6                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
        22: astore        5

4.String str6 = str5.intern()

根据之前分析的intern()方法的特点，str5.intern()尝试将str5放入串池，此时发现串池已经包含了值为"ab"的对象，所以该方法的返回值为串池中的"ab"对象，所以str3 == str6。

5.String str7 = str1 + str2

String str7 = str1 + str2编译后的虚拟机指令如下，我们来逐步分析下。第一步，创建一个StingBuilder对象；第二步，调用StringBuilder的初始化方法；第三步，加载1号槽位的变量，也就是str1，并将str1作为参数，调用StringBuilder的append方法；第四步，加载2号槽位的变量str2，并将str2作为参数，调用StringBuilder的append方法；第五步，调用StringBuilder的toString方法；第六步，将上一步的结果，存入7号槽位。通过跟踪StringBuilder的toString方法，发现该方法，其实是在堆中创建了一个字符串对象。因此，str3 != str7。

        31: new           #8                  // class java/lang/StringBuilder
        34: dup
        35: invokespecial #9                  // Method java/lang/StringBuilder."<init>":()V
        38: aload_1
        39: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        42: aload_2
        43: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        46: invokevirtual #11                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        49: astore        7

StringBuilder的toString方法

    @Override
    public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
    }

 6.String str8 = str1 + "b"

这种情况和上一种情况类似，唯一不同的是，"b"是直接从常量池读取的。因此，str3 != str8。

        51: new           #8                  // class java/lang/StringBuilder
        54: dup
        55: invokespecial #9                  // Method java/lang/StringBuilder."<init>":()V
        58: aload_1
        59: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        62: ldc           #3                  // String b
        64: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        67: invokevirtual #11                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        70: astore        8

 7.String str9 = new String("a") + new String("b");

这种情况和上一种情况类似，不同的是，还在堆中创建了两个字符串对象。因此，str3 != str9。

        72: new           #8                  // class java/lang/StringBuilder
        75: dup
        76: invokespecial #9                  // Method java/lang/StringBuilder."<init>":()V
        79: new           #5                  // class java/lang/String
        82: dup
        83: ldc           #2                  // String a
        85: invokespecial #6                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
        88: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        91: new           #5                  // class java/lang/String
        94: dup
        95: ldc           #3                  // String b
        97: invokespecial #6                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
       100: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
       103: invokevirtual #11                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
       106: astore        9

分析完了，验证下结果（需要注意的是，这是在jdk1.8下运行的，其他的版本结果可能会稍有不同）

str3 == str4 :true
str3 == str5 :false
str3 == str6 :true
str3 == str7 :false
str3 == str8 :false
str3 == str9 :false

附加题

    public static void main(String[] args) {
        String str5 = new String("a") + new String("b");
        str5.intern();
        String str3 = "ab";

        System.out.println("str3 == str5 :" + (str3 == str5));
    }

 String str5 = new String("a") + new String("b")的执行流程如下：

  • 创建一个StingBuilder对象。

  • 调用StringBuilder的初始化方法。

  • 加载运行时常量池的字符串"a"，由于此时运行常量池的"a"还只是一个符号，所以会首先创建一个"a"对象，放入串池中，然后返回。

  • 在堆中创建一个字符串对象，构造参数是"a"。

  • 将上一步创建的对象作为参数，调用StringBuilder的append方法

  • 加载运行时常量池的字符串"b"，由于此时运行常量池的"b"还只是一个符号，所以会首先创建一个"b"对象，放入串池中，然后返回。

  • 在堆中创建一个字符串对象，构造参数是"b"。

  • 将上一步创建的对象作为参数，调用StringBuilder的append方法

  • 调用StringBuilder的toString方法，在堆中创建一个值为"ab"的字符串对象。

str5.intern()将上一步在堆中创建的"ab"对象放入了串池。str3会在运行时常量池找到符号"ab"，然后根据符号"ab"去串池中查找对象，发现已经有了，就直接返回串池中的"ab"对象。因此，str3 == str5。

         0: new           #2                  // class java/lang/StringBuilder
         3: dup
         4: invokespecial #3                  // Method java/lang/StringBuilder."<init>":()V
         7: new           #4                  // class java/lang/String
        10: dup
        11: ldc           #5                  // String a
        13: invokespecial #6                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
        16: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        19: new           #4                  // class java/lang/String
        22: dup
        23: ldc           #8                  // String b
        25: invokespecial #6                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
        28: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        31: invokevirtual #9                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        34: astore_1
        35: aload_1
        36: invokevirtual #10                 // Method java/lang/String.intern:()Ljava/lang/String;
        39: pop
        40: ldc           #11                 // String ab
        42: astore_2

 

总结

  1. 运行常量池中的字符串是延迟加载，只有在第一次访问的时候，才会创建一个字符串对象，并将这个对象放入常量池。
  2. 对于字符串相加的场景，编译器在编译时会做优化。如果时两个字符串常量直接相加，编译器会直接把相加的结果赋值给变量（String str = "a" + "b" ==> String str = "ab"）。其他情况，都会创建一个StringBuilder对象，然后调用append和toString方法，最后在堆中创建一个字符串对象。
  3. intern()方法，调用该方法将字符串放进串池，如果串池没有值相同的字符串对象，则将原字符串对象放进串池，并返回串池中的对象；如果有值相同的字符串对象，直接返回串池中的对象。

 

 

一个上进的螺丝钉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
JAVA--OOP思想（1）
weixin_50563955的博客
11-26 271
面向对象1 1.1 面向对象 1.1.1 概念 所谓的面向对象是一种编程思想，通过这种思想可以把生活中的复杂事情变得简单化，从原来的执行者变成了指挥者，面向对象是基于面向过程而言的。 我们经常说的面向对象的编程实现（OOP，Object Oriented Programming） 面向过程强调的是过程，例如： 1、打开冰箱 2、把大象放进去 3、关上冰箱 面向对象强调结果，例如： 1、 饿了，去平台点餐，这个动作就是面向对象。你没有去市场买菜洗菜做饭。。。只要有app就可以了。 2、
Java中String详解（从原理理解经典面试题）
全栈行动派的博客
03-04 841
通过JVM\字节码\String特性，深入理解String经典面试题，告别死记硬背，从原理上解答面试题
StringTable&String的常见面试题
qq_43684005的博客
08-12 199
1. 基本特性 String：字符串，使用一对""引起来表示 String声明为final的，不可被继承 String实现了Serializable接口：表示字符串是支持序列化的。 String实现了Comparable接口：表示string可以比较大小 String在jdk8及以前内部定义了final char[] value用于存储字符串数据。JDK9时改为byte[] 为什么在JDK9的时候更改String的内部结构？ Java8及以前，String内部使用一个char[]保存UTF-
String a="123"创建对象个数问题
baidu_27969827的博客
02-01 3659
String类型对象创建个数，我总结为一下几种情况(均不考虑字符串在常量池中已存在的情况)： 1 String a="123"; 创建了1个对象 jvm在编译阶段会判断常量池中是否有 "123" 这个常量对象如果有，a直接指向这个常量的引用，如果没有会在常量池里创建这个常量对象。 2  String a=new String("123"); 创建了2个对象 同情况1，jvm编译阶段判断
String类详细解析
qq_45744182的博客
11-05 328
String类详细解析 1、String的构造方式： //方法一 String str="Hello"; //方法二 String str1=new String("Hello"); //方法三 char[] array={'a','b','c','d'}; String str2= new String(array); 2、字符串相等比较 public static void main...
string字符串处理1-定义属性输出
renwu
08-05 1594
1.定义 string提供6个构造函数和一个拷贝构造函数，所以，string数据的初始化就有7种方式 1）输入的参数为空 string(); //构造函数1 string str1; //定义一个str字符串，该字符串为空 2）用n个字符初始化string对象 string(size_type length, char ch); //构造函数2 string str...
StringTable常见面试问题
qq_38785977的博客
08-28 167
【代码】StringTable常见面试问题。
JVM-StringTable面试题
Eistert
08-02 151
StringTable面试题： String s1 = "a"; String s2 = "b"; String s3 = "a" + "b"; String s4 = s1 + s2; String s5 = "ab"; String s6 = s4.intern(); // 问 System.out.println(s3 == s4); System.out.println(s3 == s5); System.out.println(s3 == s6); String x2 =
面试冲刺——StringTable（串池）
种一颗十年前的树
02-29 403
StringTable String table又称为String pool，字符串常量池，其存在于堆中(jdk1.7之后改的)。最重要的一点，String table中存储的并不是String类型的对象，存储的而是指向String对象的索引，真实对象还是存储在堆中。 此外String table还存在一个hash表的特性，里面不存在相同的两个字符串。 此外String对象调用intern()...
看了这篇文章别再跟我说你面试挂在了String的面试题上
热门推荐
yuge1123的博客
03-14 1万+
首先来看一到面试题，不管你能不能答上来，我都相信你能够在这篇文章学到一些你以前不知道的知识 String s1 = "a"; String s2 = "b"; String s3 = "a" + "b"; String s4 = s1 + s2; String s5 = "ab"; String s6 = s4.intern(); // 问 System.out.println(s3 == s4...
StringTable面试题
weixin_43783251的博客
07-19 145
public static void main(String[] args){ String s1 = "a"; String s2 = "b"; String s3 = "a" + "b";//编译期优化为”ab“，常量池没有，入池 String s4 = s1 + s2;//new String（”ab“）堆中的对象 String s5 = "ab";//常量池中已有 String s6 = s4.intern();//池中已有，直接返回常量池中的 //问 System.out.pr
StringTable面试题，常量池在内存中的位置，串池概念
weixin_45902973的博客
03-08 613
1、概念： 1、String table又称为String pool，字符串常量池，其存在于堆中(jdk1.7之后改的)。最重要的一点，String table中存储的并不是String类型的对象，存储的而是指向String对象的索引，真实对象还是存储在堆中。 2、此外String table里面不存在相同的两个字符串。 3、此外String对象调用intern()方法时，会先在String table中查找是否存在于该对象相同的字符串，若存在直接返回String table中字符串的引用，若不存在则在St
34.jvm内存结构部分——String_table面试题[通过jvm来做题]
tgbyhn31的博客
07-05 191
有了StringTable基础，我们再来看StringTable面试题。
JVM系列-String-Table的理解
理科男同学
12-14 1001
1，String的基本特性 String：字符串，使用一对 “” 引起来表示 String s1 = "hello" ; //字面量的定义方式 String s2 = new String("hello"); // new 对象的方式 String被声明为final的，不可被继承，如果字符串需要跨进程传输，是可以的，应为String实现了序列化接口。 String实现了Serializable接口：表示字符串是支持序列化的。实现了Comparable接口：表示Strin
JVM调优-StringTable结构以及基本调优
qq_42411214的博客
08-24 452
对StringTable串池不了解朋友可以看我的博客 JDK1.8中StringTable的底层类似于HashTable，由数组和链表实现，数组又称为桶数组。比如有这样一段代码： public class Demo4 { public static void main(String[] args) { int i = 0; System.out.println(i); } } 我们设置虚拟机参数“-Xmx10m -XX:+PrintStringTableSt
查看字节码 javap -v xxx.class
串一串爪娃子
12-29 1662
public static void main(String[] args) { String s1 = "Hello"; String s2 = "Hel" + "lo"; String s3 = new String("Hello"); String s4 = "Hel" + new String("lo"); String s5 = s3.intern(); int i1
StringTable垃圾回收跟踪案例
敏叔
01-11 854
引言 很多人认为jvm字符串常量不会被回收的，其实这个说法的有误区的，我们通过一些jvm参数可以看到StringTable的垃圾回收。 参数说明
Java String 面试题以及答案
程序员yqy的博客
12-08 4580
String是最常使用的Java类之一，整理的了一些重要的String知识分享给大家。 作为一个Java新手程序员，对String进行更深入的了解很有必要。如果你是有几年Java开发经验，可以根据目录选择性的阅读以下内容。
Stringtable 串池经典面试题
trigger的博客
03-02 160
Stringtable串池 简单介绍 常量池中的字符串仅是符号，第一次用到时才变为字符串对象 利用串池的机制，来避免重复创建字符串对象 ，如果两个字符串（作为key）一样，那么就会使用同一份。 可以使用 intern 方法，主动将串池中还没有的字符串对象放入串池 1.6 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有会把此对象复制一份（原来的对象没有变，只是在常量池中多了一个字符串）， 放入串池， 会把串池中的对象返回。 1.8 将这个字符串对象尝试放入串池，如果有则并不会放入，如果
jvm StringTable
最新发布
07-25
JVM的StringTable是用于存储字符串常量的数据结构。在JVM中，字符串常量是指在代码中直接使用双引号括起来的字符串。 StringTable是一个哈希表，用于实现字符串常量的唯一性。它的作用是避免在内存中重复存储相同的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值