【JVM学习】StringTable（字符串常量池）—— 字节码角度解释各种String对象的创建与比较

甲烷

已于 2022-06-19 23:23:54 修改

阅读量301

点赞数

分类专栏： JVM学习笔记文章标签： jvm string

于 2021-12-12 23:04:23 首次发布

本文链接：https://blog.csdn.net/weixin_44179010/article/details/121888449

版权

JVM学习笔记专栏收录该内容

7 篇文章 2 订阅

订阅专栏

String 的基本特性

两种实例化方式

String s1 = "hello";//字面量的定义方式
String s2 = new String("hello");

String 声明为final，是不可被继承的
String实现了Serializable接口，表示支持序列化；实现了Comparable接口，表示支持比较大小

JDK1.8及之前String底层是char[] 数组，而JDK1.9之后变成byte[] 数组加上编码标记，节约了一些空间
String的不可变性，不管是拼接还是API的替换，都是新造一个字符串，不会改变原来的字符串。

字符串常量池【String Pool】

字符串常量池中是不会存储相同的字符串的
String Pool是一个固定大小的Hashtable【数组加链表】，JDK6中默认大小长度是1009，JDK7中默认长度是60013，1009是可设置的最小值【如果String pool的长度小，而Sting 有很多的话，就会导致Hash冲突，从而使得链表会很长，影响调用】
使用-XX:StringTableSize=xx 设置

String的内存分配

JDK6-永久代
JDK7-永久代，字符串常量池拿到了堆空间
JDK8-元空间，字符串常量池还在堆空间

字符串拼接操作

1.常量与常量的拼接结果在常量池，原理是编译器优化
2.只要有变量，结果就在堆中（相当于new对象），变量拼接原理是：StringBuilder
3.如果拼接的结果调用intern()方法，则主动将常量池中还没有的字符串对象放入池中，并返回此对象地址。
示例代码：

    @Test
    public void test1(){
        String s1 = "a"; //”“引号赋值，直接在字符串常量池创建这个字符串,然后返回这个字符字面量
                         //然后将变量保存到局部变量表的索引1位置，索引0位置放的是this
        String s2 = "b"; //同理
        String s3 = "ab"; //同理
        /*
            s1+s2 执行细节：【如果s1,s2 为字面量或者加了final 则会-使用编译期优化，会自动合并到一起】
             ①StringBuilder s = new StringBuilder();
             ②s.append("a");
             ③s.append("b");
             ④s.toString();  --> 约等于 new String("ab");
         */
        String s4 = s1 + s2;//s1 s2 是变量， 如果s1,s2是常量的话就不会new了
        System.out.println("s3==s4 " + s3 == s4); //false
    }

示例代码的字节码：

 0 ldc #2 <a>       
 2 astore_1
 3 ldc #3 <b>
 5 astore_2
 6 ldc #4 <ab>
 8 astore_3
 # s4创建开始
 9 new #5 <java/lang/StringBuilder>
12 dup
13 invokespecial #6 <java/lang/StringBuilder.<init> : ()V>
16 aload_1
17 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
20 aload_2
21 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
24 invokevirtual #8 <java/lang/StringBuilder.toString : ()Ljava/lang/String;>
27 astore 4
29 getstatic #9 <java/lang/System.out : Ljava/io/PrintStream;>
32 new #5 <java/lang/StringBuilder>
35 dup
36 invokespecial #6 <java/lang/StringBuilder.<init> : ()V>
# s4创建完成
39 ldc #10 <s3==s4 >
41 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
44 aload_3
45 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
48 invokevirtual #8 <java/lang/StringBuilder.toString : ()Ljava/lang/String;>
51 aload 4
53 if_acmpne 60 (+7)
56 iconst_1
57 goto 61 (+4)
60 iconst_0
61 invokevirtual #11 <java/io/PrintStream.println : (Z)V>
64 return

intern() 的使用

String info = new String("AAA").intern();

intern方法会从字符串常量池中查询当前字符串是否存在
若不存在，就会将当前字符串放入常量池中，返回常量池中字符串的地址，
jdk7/8后，如果堆空间已经有"AAA"字符串，则会把字符串"AAA"的地址放入常量池
若存在，返回常量池中的字符的地址
【字符串常量池中可能有字符串字面量和字符串地址，但是不会有equal 为true的两个对象】

面试题目

创建了几个对象

1.new String(“AB”) 会创建几个对象。

答：一个或者两个
代码及字节码：

    @Test
    public void stringNewTest(){
        String str = new String("AB");
    }
/**************字节码**********************/
 0 new #12 <java/lang/String>   #/*堆空间new了一个*/
 3 dup
 4 ldc #13 <AB>  				#/*常量池创建了一个*/
 6 invokespecial #14 <java/lang/String.<init> : (Ljava/lang/String;)V>
 9 astore_1
10 return

解释：由字节码可以很容易看出，代码创建了两个对象，一个是堆空间new的对象，一个是字符串常量池中创建了一个对象
创建一个对象的情况是：当字符串常量池中已经有了字符串"AB",就不会再在字符串常量池创建了

2.new String(“a”) + new String(“b”)会创建几个对象？

代码及字节码：

    @Test
    public void stringNewTest(){
        //String str = new String("AB");
        String str = new String("A") + new String("B");
    }
/*********************字节码******************************/
 0 new #5 <java/lang/StringBuilder>     								#//一
 3 dup
 4 invokespecial #6 <java/lang/StringBuilder.<init> : ()V>
 7 new #12 <java/lang/String> 										 	#//二
10 dup
11 ldc #13 <A>															#//三
13 invokespecial #14 <java/lang/String.<init> : (Ljava/lang/String;)V>
16 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
19 new #12 <java/lang/String>											#//四
22 dup
23 ldc #15 <B>															#//五
25 invokespecial #14 <java/lang/String.<init> : (Ljava/lang/String;)V>
28 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
31 invokevirtual #8 <java/lang/StringBuilder.toString : ()Ljava/lang/String;> #//六 toString()方法
34 astore_1
35 return

解释：

两个变量拼接，会首先创建出一个StringBuilder()对象
new String(“A”)
在字符串常量池中创建"A"
new String(“B”)
在字符串常量池中创建"B"
StringBuilder的toString()方法，会new String(“AB”)，但不会在字符串常量池创建"AB"

StringBuilder的toString()方法源码刨析：

    @Override
   public String toString() {
       // Create a copy, don't share the array
       return new String(value, 0, count);
   }
/********************字节码***************************/
 0 new #80 <java/lang/String>
 3 dup
 4 aload_0
 5 getfield #234 <java/lang/StringBuilder.value : [C>
 8 iconst_0
 9 aload_0
10 getfield #233 <java/lang/StringBuilder.count : I>
13 invokespecial #291 <java/lang/String.<init> : ([CII)V>
16 areturn

从字节码也可以看出StringBuilder()的toString()方法会创建一个new String(“AB”),但是不会在字符串常量池创建"AB"
所以new String(“a”) + new String(“b”) 这句话执行后，字符串常量池中不会有"AB"

如何保证变量s指向的是字符串常量池中的数据呢？
方式一：String s = “ygstriver”;
方式二：调用intern(), String s = new String(“ygstriver”).intern()

intern() 面试难题

    @Test
    public void stringIntern(){
        String s1 = new String("A");
        s1.intern(); //未执行这句代码之前，字符串常量池中就有"A"了
        			//执行了这句话，因为常量池中有"A"了，所以不会做任何事，返回值为字符串常量池中"A"的地址
        String s2 = "A";
        System.out.println(s1 == s2);// jdk6: false,  jdk7/8: false

        String s3 = new String("A") + new String("B");//约等于 new String("AB"),唯一区别是没有在常量池创建"AB"或"AB"的引用
        s3.intern(); //这句话会在常量池创建"AB"
        			//	JDK6，字符串常量池在永久代中，所有此时是在常量池中新创建了一个"A"的字面量。而
        			//JDK7/8, 字符串在堆空间中， new的对象也在堆空间中，所以字符串常量池不会创建一个新的"A"的字面量，
        			//而是会创建一个字符串对象的引用，这个引用指向堆空间中new出来的字符串
        String s4 = "AB";//从字符串常量池取值，取到AB的引用，这引用正式new String("AB")的地址值 
        System.out.println(s3 == s4); //jdk6: false,  jdk7/8: true
    }

解释：

s1是在堆空间创建出的字符串对象，s2是字符串常量池中的对象，他们不相等很容易理解。
s3赋值代码执行完，字符串常量池中是没有"AB"字符串的.
而执行了s3.intern()之后，字符串常量池有"AB"了，
但是 jdk7/8中这个"AB"不是字面量"AB"，而是一个引用，引用指向堆空间中new String(“AB”)的地址，
s4引号赋值，从字符串常量池取到"AB"的引用，而这个引用对应的地址值正是new String(“AB”)的地址值，也就是s3的值，所以s3 == s4

图解：
请添加图片描述
小拓展：

String s3 = new String("A") + new String("B"); //执行完这句代码字符串常量池不存在"AB"
String s4 = "AB"; //执行完这句 字符串常量池存在 "AB"的字面量,返回的是字符串常量池中"AB"的地址
String s5 = s3.intern();      //执行完这句，字符串常量池还是存在"AB"的字面量，这句话返回的也是字符串常量池中"AB"的地址
System.out.println(s3 == s4); //false
System.out.println(s5 == s4); //true

练习题1：

String ss1 = new String("a") + new String("b");
String ss2 = ss1.intern();
System.out.println(ss2 == "ab"); //true
System.out.println(ss1 == "ab"); //jdk6:false  jdk7/8: true

练习题2：

String ss3 = new String("ab");
String ss4 = ss3.intern();
System.out.println(ss3 == ss4); //false

intern()的空间效率.

对于程序中大量存在的字符串，尤其存在很多重复字符串时，使用intern()可以节约大量空间
【因为重复的字符串我们用intern()是指向字符串常量池的，堆空间new出来的大量重复字符串就会被回收】
G1垃圾回收器有堆空间去重操作，默认不开启

甲烷

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【JVM学习】StringTable（字符串常量池）—— 字节码角度解释各种String对象的创建与比较

String 的基本特性两种实例化方式String s1 = "hello";//字面量的定义方式String s2 = new String("hello");String 声明为final，是不可被继承的String实现了Serializable接口，表示支持序列化；实现了Comparable接口，表示支持比较大小JDK1.8及之前String底层是char[] 数组，而JDK1.9之后变成byte[] 数组加上编码标记，节约了一些空间String的不可变性，不管是拼接还是API的
复制链接

扫一扫