java-方法区 (二) - StringTable串池

最新推荐文章于 2023-11-15 16:26:41 发布
最新推荐文章于 2023-11-15 16:26:41 发布
阅读量401 收藏
点赞数 3
分类专栏： 笔记 文章标签： 字符串 java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43539962/article/details/113918168
版权

StringTable 字符串拼接 编译期优化 intern() Java内存管理
关键词由CSDN通过智能技术生成

方法区StringTable串池


StringTable是方法区的重要组成部分

字符串入池

案例:

public class Test2 {
    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        String ab = "ab";
    }
}

编译成class文件后又编译回来

 Last modified 2021-2-21; size 508 bytes
  MD5 checksum 6dfdd4fd20e3dfb96ca5557dca082e97
  Compiled from "Test2.java"
public class com.cdyl.api.Test2
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #6.#25         // java/lang/Object."<init>":()V
   #2 = String             #18            // a
   #3 = String             #20            // b
   #4 = String             #21            // ab
   #5 = Class              #26            // com/cdyl/api/Test2
   #6 = Class              #27            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lcom/cdyl/api/Test2;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               a
  #19 = Utf8               Ljava/lang/String;
  #20 = Utf8               b
  #21 = Utf8               ab
  #22 = Utf8               MethodParameters
  #23 = Utf8               SourceFile
  #24 = Utf8               Test2.java
  #25 = NameAndType        #7:#8          // "<init>":()V
  #26 = Utf8               com/cdyl/api/Test2
  #27 = Utf8               java/lang/Object
{
  public com.cdyl.api.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 5: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/cdyl/api/Test2;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=4, args_size=1
         0: ldc           #2                  // String a
         2: astore_1
         3: ldc           #3                  // String b
         5: astore_2
         6: ldc           #4                  // String ab
         8: astore_3
         9: return
      LineNumberTable:
        line 7: 0
        line 8: 3
        line 9: 6
        line 10: 9
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      10     0  args   [Ljava/lang/String;
            3       7     1     a   Ljava/lang/String;
            6       4     2     b   Ljava/lang/String;
            9       1     3    ab   Ljava/lang/String;
    MethodParameters:
      Name                           Flags
      args
}
SourceFile: "Test2.java"

常量池中的信息，都会被加载到运行时常量池中，这时a b ab 都还是常量池中的符号，还没有变为字符串对象
在这里插入图片描述
当运行到 ldc #2 会把 a 符号变为"a" 字符串对象 这时会去StringTable里面去找一次如果没有就会放入StringTable，如果有了则把StringTable里面的字符串对象返回 ，后面的 ldc #3 ldc #4同理

字符串拼接原理

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

同理进行反编译拿到jvm指令

 Last modified 2021-2-21; size 691 bytes
 MD5 checksum a373a0219f010580b0f60dcd3e8cbf1d
 Compiled from "Test2.java"
public class com.cdyl.api.Test2
 minor version: 0
 major version: 52
 flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
  #1 = Methodref          #10.#30        // java/lang/Object."<init>":()V
  #2 = String             #22            // a
  #3 = String             #24            // b
  #4 = String             #25            // ab
  #5 = Class              #31            // java/lang/StringBuilder
  #6 = Methodref          #5.#30         // java/lang/StringBuilder."<init>":()V
  #7 = Methodref          #5.#32         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #8 = Methodref          #5.#33         // java/lang/StringBuilder.toString:()Ljava/lang/String;
  #9 = Class              #34            // com/cdyl/api/Test2
 #10 = Class              #35            // java/lang/Object
 #11 = Utf8               <init>
 #12 = Utf8               ()V
 #13 = Utf8               Code
 #14 = Utf8               LineNumberTable
 #15 = Utf8               LocalVariableTable
 #16 = Utf8               this
 #17 = Utf8               Lcom/cdyl/api/Test2;
 #18 = Utf8               main
 #19 = Utf8               ([Ljava/lang/String;)V
 #20 = Utf8               args
 #21 = Utf8               [Ljava/lang/String;
 #22 = Utf8               a
 #23 = Utf8               Ljava/lang/String;
 #24 = Utf8               b
 #25 = Utf8               ab
 #26 = Utf8               s
 #27 = Utf8               MethodParameters
 #28 = Utf8               SourceFile
 #29 = Utf8               Test2.java
 #30 = NameAndType        #11:#12        // "<init>":()V
 #31 = Utf8               java/lang/StringBuilder
 #32 = NameAndType        #36:#37        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
 #33 = NameAndType        #38:#39        // toString:()Ljava/lang/String;
 #34 = Utf8               com/cdyl/api/Test2
 #35 = Utf8               java/lang/Object
 #36 = Utf8               append
 #37 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
 #38 = Utf8               toString
 #39 = Utf8               ()Ljava/lang/String;
{
 public com.cdyl.api.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 4: 0
     LocalVariableTable:
       Start  Length  Slot  Name   Signature
           0       5     0  this   Lcom/cdyl/api/Test2;

 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 b
        5: astore_2
        6: ldc           #4                  // String ab
        8: astore_3
        9: new           #5                  // class java/lang/StringBuilder
       12: dup
       13: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
       16: aload_1
       17: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
       20: aload_2
       21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
       24: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
       27: astore        4
       29: return
     LineNumberTable:
       line 6: 0
       line 7: 3
       line 8: 6
       line 9: 9
       line 10: 29
     LocalVariableTable:
       Start  Length  Slot  Name   Signature
           0      30     0  args   [Ljava/lang/String;
           3      27     1     a   Ljava/lang/String;
           6      24     2     b   Ljava/lang/String;
           9      21     3    ab   Ljava/lang/String;
          29       1     4     s   Ljava/lang/String;
   MethodParameters:
     Name                           Flags
     args
}
SourceFile: "Test2.java"

在这里插入图片描述
通过指令给我们的注释我们发现其实底层的是用了StringBuilder的append进行两次拼接，然后通过toString方法转为字符串后返回。
不看注释通过常量池自己定位也是可以的具体看上一篇文章,这里就不进行详细说明
在这里插入图片描述
最终执行的其实是String s= new StringBuilder().append(a).append(b).toString();
而toString是通过新创建一个字符串对象返回
在这里插入图片描述
所以说 ab和s 是不相同的 s是通过new String来的 而ab是在StringTable里的
在这里插入图片描述
代码验证也的确如此

编译期优化

还是先看一个例子
在这里插入图片描述
问ab是否和s是同一个对象?
不清楚还是反编译一下看看对象的常量池

 Last modified 2021-2-21; size 481 bytes
  MD5 checksum 2591a843da775e0d115c1c8ec58d3447
  Compiled from "Test2.java"
public class com.cdyl.api.Test2
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #4.#22         // java/lang/Object."<init>":()V
   #2 = String             #16            // ab
   #3 = Class              #23            // com/cdyl/api/Test2
   #4 = Class              #24            // java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Utf8               Code
   #8 = Utf8               LineNumberTable
   #9 = Utf8               LocalVariableTable
  #10 = Utf8               this
  #11 = Utf8               Lcom/cdyl/api/Test2;
  #12 = Utf8               main
  #13 = Utf8               ([Ljava/lang/String;)V
  #14 = Utf8               args
  #15 = Utf8               [Ljava/lang/String;
  #16 = Utf8               ab
  #17 = Utf8               Ljava/lang/String;
  #18 = Utf8               s
  #19 = Utf8               MethodParameters
  #20 = Utf8               SourceFile
  #21 = Utf8               Test2.java
  #22 = NameAndType        #5:#6          // "<init>":()V
  #23 = Utf8               com/cdyl/api/Test2
  #24 = Utf8               java/lang/Object
{
  public com.cdyl.api.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 4: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/cdyl/api/Test2;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=3, args_size=1
         0: ldc           #2                  // String ab
         2: astore_1
         3: ldc           #2                  // String ab
         5: astore_2
         6: return
      LineNumberTable:
        line 6: 0
        line 7: 3
        line 8: 6
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       7     0  args   [Ljava/lang/String;
            3       4     1    ab   Ljava/lang/String;
            6       1     2     s   Ljava/lang/String;
    MethodParameters:
      Name                           Flags
      args
}
SourceFile: "Test2.java"

在这里插入图片描述
我们查看常量池发现只有一个String ab 那a,b又去哪了啊。
其实java在编译的时候如果发现是2个常量相拼接那么这个值就是确定的
比如

 String s = "a" + "b";

其结果必然是ab那么在编译的时候就会直接编译成ab，我们打开编译过后的class文件用idea自带的反编译打开
在这里插入图片描述
看到的确定是String s = "ab"; 而不是String s = "a" + "b";，那么第一个ab变量被赋值的时候会同时放一份在StringTable中 而s赋值的时候发现StringTable已经有"ab"字符串了，那么就会直接用StringTable中的"ab"进行赋值那么 ab和s 就是同一个对象
在这里插入图片描述

intern() 主动入池

intern方法就是主动把字符串入池，在jdk1.6和jdk1.8返回的有稍许不同，1.6会先看看是否StringTable串池中是否有，如果没有则说明可以入池，那么他会自我复制一份把复制的那份入池，而在1.8中则不会复制而是直接把字符串对象入池

public class Test2 {
    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        String s=a+b;
        String ab = "ab";
        System.out.println(s==ab);
    }
}

前面以前说明了字符串拼接是通过StringBuilder的append进行两次拼接，然后通过toString方法转为字符串后返回，一个是堆里的字符串一个是StringTable串池里的字符串
在这里插入图片描述
所以肯定是false

public class Test2 {
    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        String s=a+b;
        s.intern(); // 入池操作
        String ab = "ab"; // 那么这个ab也是从StringTable拿的
        System.out.println(s==ab); // 那么s和ab就是一个对象
    }
}

我们在ab之前就把s先入池，那么这时ab去常量池中那拿到ab符号转为字符串"ab"，然后去StringTable中看发现已经有了那么就会拿StringTable中的返回那么s和ab就是同一个对象
在这里插入图片描述
验证一下的确是true。

现在我们把代码顺序改一下

public class Test2 {
    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        String ab = "ab";
        String s=a+b;
        s.intern();
        System.out.println(s==ab);
    }
}

在这里插入图片描述
这时发现变成了false，这时咋回事啊

public class Test2 {
    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        // ab初始化入池成功
        String ab = "ab";
        String s=a+b;
        // s入池这时发现池中已经有ab了那么入池失败
        s.intern();
        // 所以s和ab就不是同一个对象
        System.out.println(s==ab);
    }
}

前面ab就已经入池成功了，后面s再入池就会失败因为里面已经有"ab"字符串了，所以s和ab就是2个不同的字符串

StringTable的位置

在这里插入图片描述

StringTable大小设置和调优

JVM参数设置： -XX:StringTableSize=60013

因为StringTable是类似于hashTable的结构这个设置的只是设置的哈希桶的大小（类似于数组最大的长度），如果字符串比较多设置小了会导致每个位置的链表过长导致查询插入过慢。

404QAQ
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java 深入JVM分析String StringTable
weixin_46711906的博客
06-12 445
1、字符串常量池Jdk1.7之前位于方法区，1.7开始位于堆2、字符串常量池中同样的数据只存储一份（固定大小HashTable存储数据）3、使用 -XX:StringTableSize 可设置大小，不会像HashMap一样动态扩容，值太小造型Hash冲突严重，调用String.interns时性能会大幅下降4、Jdk1.8中默认大小60013，1009是可设置最小值1、通过StringBuilder的append()方法拼接字符串，自始至终只会创建一个StringBuilder的对象.........
JVM---StringTable（字符串常量池）
qq_33626996的博客
03-25 700
StringTable（字符串常量池） String的基本特性 String：字符串，使用一对 " " 引起来表示。 String s1 = "atguigu" ; // 字面量的定义方式 String s2 = new String("hello"); // new 对象的方式 String 被声明为 final 的，不可被继承。 String 实现了 Serializable 接口：表示字符串是支持序列化的；实现了 Comparable 接口：表示 String 可以比较大
尚硅谷JVM从入门到精通宋红康版|第十三章、StringTable
weixin_45759791的博客
07-13 743
StringTable String的基本特性 String：字符串，使用一对 ”” 引起来表示 String s1 = “mogublog” ; // 字面量的定义方式 String s2 = new String(“moxi”); string声明为final的，不可被继承 String实现了Serializable接口：表示字符串是支持序列化的。实现了Comparable接口：表示string可以比较大小 string在jdk8及以前内部定义了final char[] value用于存储
【Java 笔记】JVM : StringTable
JJ_Notebook的博客
04-23 1110
这里写目录标题JVM更新：String Table字节码解释测试代码字节码文件根据字节码文件理解JVM中StringTable的实现String Table编译器调优 JVM更新： String Table 常量池中的字符串仅仅是字面符号，只有当执行到对应的JVM指令时，才会生成对象，利用串池避免重复创建字符串对象，JDK1.8串池从常量池中移动到Heap中。String table是一个has...
Java虚拟机 -- StringTable
Forlogenの解忧杂货铺
06-12 389
文章目录1. String 的特性1.1 基本特性1.2 字符串的修改2. 字符串常量池3. String的内存分配4. String基本操作4.1 实例化4.2 拼接5. intern方法5.1 概述5.2. 面试题5.2.1 new String5.2.2 new String("a") + new String("b")5.3 总结6. String去重操作 1. String 的特性 1.1 基本特性 String 类型的数据表现形式是使用" "表示的字符串 String声明为final，
StringTable字符串池介绍
JAVA菜鸟
04-20 127
String_Table 常量池与字符串池的关系 我们先准备了一点简单的代码: public class StringTable1 { public static void main(String[] args) { String s1 = "a"; String s2 = "b"; String s3 = "ab"; } } 上面代码运行完成以后生成StringTable1.class对象, 然后通过 javap -v StringTab
StringTable(串池)详解
WenJieya的博客
05-05 1456
文章目录1. 常量池与串池的关系2. 字符串【变量】拼接的原理 StringBuilder3. 编译期优化（字符串【常量】拼接的原理）4. 字符串延迟加载5. 可使用intern方法，主动将串池中还没有的字符串对象放入串池5.1 jdk1.8、1.7以后的intern，将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池，并且会把串池中的对象返回5.2. jdk1.6的intern，将这个字符串对象尝试放入串池，如果有则并不会放入，【【如果没有则会把此对象复制一份再 放入串池】】，并且会把串
8 StringTable（字符串常量池）.md，学习代码
最新发布
06-25
字符串常量池是一个特殊的区域，位于Java虚拟机（JVM）的内存结构中的方法区或元空间。它存储了程序中所有的字符串字面量（即用双引号定义的字符串）。当一个字符串被创建时，JVM会首先检查池中是否存在相同的字符串...
java - 字符串 String
peroy000000的博客
07-26 125
/** * String 的不可变性 * * String jdk1.8 用 char[]存储，jdk1.9用byte[] */ public class StringTest1 { public void test1(){ //引用变量 s1，s2 存储在main线程的线程栈中的main方法的栈帧中的局部变量表中 //字面量 abc 存储在字符串常量池中，字符串常量池中不允许放相同的字符串；jdk1.8中字符串常量池在堆空间中 //s.
StringTable（字符串常量池）
qq_44346427的博客
04-07 483
StringTable（字符串常量池） String的基本特性 String：字符串，使用一对 “” 引起来表示 String s1 = "chinese";// 字面量的定义方式 String s2 = new String("hello");// new 对象的方式 String被声明为final的，不可被继承 String实现了Serializable接口：表示字符串是支持序列化的。实现了Comparable接口：表示String可以比较大小 String在jdk8及以前内部定义了
JVM上篇_13_StringTable_尚硅谷
Java全栈开发者
06-25 217
官方文档：https://openjdk.java.net/jeps/254The current implementation of the class stores characters in a array, using two bytes (sixteen bits) for each character. Data gathered from many different applications indicates that strings are a major component of
Java中StringTable的理解
m0_56085369的博客
06-27 601
StringTable 定义 俗称串池，用于存储字符串类型的引用。 存储位置 JDK1.6的时候存储在永久代的常量池中，JDK1.8为了提高回收效率，把StringTable存放在堆中。 结构 存储结构为HashTable，也就是数组+链表的形式，不允许扩容。 使用Hash值来确定元素应该放在数组的哪一个位置，当Hash值相同时称为哈希冲突，这时首先判断hash值相同的元素是否相同，如果是的话拒绝插入，如果不是的话则会在链表中插入元素。 特性 字符串会延迟加载,执行到该代码的时候才会加载到Str
Java虚拟机（十二）——StringTable
稷下学员的笔记博客
12-10 530
String 的基本特性 字符串，用""引起来表示 声明为final的，不可被继承 实现了Serializable接口，表示字符串支持序列化，实现了Comparable接口，表示String可以比较大小。 String在JDK8以及以前内部定义了final char[]存储字符串数据 ，JDK9之后改用了final byte []。 修改是因为部分字符集使用char会导致一个字节的空间浪费。 Motivation The current implementation of the St
面试冲刺——StringTable（串池）
种一颗十年前的树
02-29 407
StringTable String table又称为String pool，字符串常量池，其存在于堆中(jdk1.7之后改的)。最重要的一点，String table中存储的并不是String类型的对象，存储的而是指向String对象的索引，真实对象还是存储在堆中。 此外String table还存在一个hash表的特性，里面不存在相同的两个字符串。 此外String对象调用intern()...
Java --- JVM之StringTable
qq_46093575的博客
11-15 205
总结：在jdk6中，如果串池中有，就返回已有的串池中的对象的地址，如果没有，就是将这个对象复制一份，放入串池，并返回这个对象的地址。从jdk7起，如果串池中有，就返回已有的串池中的对象的地址，如果没有，就是将这个对象的引用地址复制一份，放入串池，并返回串池中的引用地址。③、在jdk6中的StringTable的是固定的，就是1009的长度，所以如果常量池中的字符串过多就会导致效率下降很快。4、如果拼接的结果调用intern()方法，则主动将常量池中还没有的字符串对象放入池中，并返回此对象地址。
13-方法区的演进以及StringTable的调整
Open_Coder的博客
07-22 242
方法区的演进以及StringTable的调整 《Java虚拟机规范》中明确说明：“尽管所有的方法区在逻辑上是属于堆的一部分，但一些简单的实现可能不会选择去进行垃圾收集或者进行压缩。”但对于 HotSpotJVM 而言，方法区还有一个别名叫做Non-Heap（非堆），目的就是要和堆分开。 所以，方法区看作是一块独立于Java堆的内存空间。 方法区主要存放的是『Class』，而堆中主要存放的是『实例化的对象』 方法区（Method Area）与Java堆一样，是各个线程共享的内存区域。 方法区在JVM启动的
结合字符串常量池/String.intern()/String Table来谈一下你对java中String的理解
weixin_34080571的博客
07-05 87
1、字符串常量池 每创建一个字符串常量，JVM会首先检查字符串常量池，如果字符串已经在常量池中存在，那么就返回常量池中的实例引用。如果字符串不在池中，就会实例化一个字符串放到字符串池中。常量池提高了JVM性能和内存开销 2、用new 的方式创建字符串 new方式创建字符串，会先检查常量池中是否有相同值的字符串。如果有，则拷贝一份到堆中，然后返回堆中的地址。如果没有，则在堆中创建一份，然后返回...
JVM：关于StringTable 串池
weixin_45490507的博客
10-26 147
JDK1.8的规则 String s1 = "a"; // 从串表(字符串常量池)中找是否有a这个常量，如果没有，将a添加到串表中(串表为哈希表，每个值只有1份)，并将a赋值给s1这个变量 String s2 = "b"; // 同s1的过程 String s3 = "ab"; // 同s1的过程 String s4 = s1 + s2; // 底层先创建一个StringBuffer，然后通过append()方法拼接字符串，最后通过一个new String("ab") 来创建一个新的字符串对象，存
StringTable和字符串常量池的关系
04-30
StringTable和字符串常量池是Java中两个不同的概念，但是它们之间存在着一定的关系。 字符串常量池是Java中一个特殊的内存区域，用于存储字符串常量对象。当代码中出现字符串常量时，Java会先在字符串常量池中查找...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值