String的Intern()方法，详解字符串常量池！

た入场券 2024-04-21 19:08 40阅读 0赞

#### 文章目录 ####

*   *  一、String的基本特性
     *   *  为什么jdk9String由char\[\]改为了byte\[\]去存？
         *  String存储结构发生了变更，StringBuffer和StringBuilder是否改变了？
         *  实例（因为String不可变性，原来地址的值是无法被改变的）：
     *  二、String的内存分配
     *   *  为什么要将StringTable进行调整，从永久代->堆？
     *  三、String的基本操作
     *   *  实例1：
         *  实例2：
     *  四、字符串拼接操作
     *   *  实例1：（常量与常量的拼接结果在常量池）
         *  实例2：（拼接其中有一个是变量，结果就在堆中，相当于新new的String）
         *  实例3：（字符串变量拼接底层是用StringBuilder）
         *  实例4：
         *  实例5：练习
         *  实例6：多个字符串拼接，其实也只new了一个StringBuilder
         *  实例7：for循环中拼接字符串
         *  总结：
     *  五、intern()的使用
     *   *  如何保证变量s指向字符串常量池中的数据？
         *  new String("abc")会创建几个对象？
         *  StringBuilder的toString()方法：
         *  经典题目（99%的人会做错！）
         *  拓展：
         *  总结String的intern()的使用：
         *  intern练习1：
         *  intern练习2：
     *  六、intern()效率测试
     *   *  空间角度（jdk1.8）
     *  七、StringTable的垃圾回收
     *  \*\*八、G1中的String去重操作\*\*
     *   *  \*\*实现\*\*
         *  \*\*命令行选项\*\*

### 一、String的基本特性 ###

1.String字符串，使用一对""引起来表示。

2.String声明为final的，不可被继承。

3.String实现了Serializable接口，表示字符串是支持序列化的。实现了Comparable接口，表示String可以比较大小。

4.String在jdk8及以前内部定义了final char\[\] value用于存储字符串数据。jdk9时改为byte\[\]。

5.String代表不可变的字符序列。简称：不可变性。

（1）当字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。

（2）当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。

（3）当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。

6.通过字面量的方式（区别于new，String a = ‘abc’;）给一个字符串赋值，此时字符串值声明在字符串常量池中。

7.字符串常量池中是不会存储相同内容的字符串的。

8.String的String Pool是一个固定大小的HashTable，默认值大小长度是1009.如果放进String Pool的String非常多，就会造成Hash冲突严重，从而导致链表会很长，而链表长了后直接会造成的影响就是当调用String.intern时性能会大幅下降。

9.使用-XX:StringTableSize可以设置StringTable的长度。

10.在jdk6中StringTable是固定的，就是1009的长度，所以如果常量池中的字符串过多就会导致效率下降很快。StringTableSize设置没有要求。

11.在jdk7中，StringTable的长度默认值是60013，StringTable的设置没有要求。

12.jdk8中，StringTable的长度默认值是60013，1009是可设置的最小值。

#### 为什么jdk9String由char\[\]改为了byte\[\]去存？ ####

主要还是节省空间。

JDK9 之前的库的 String 类的实现使用了 char 数组来存放字符串，char 占用16位，即两字节。

研究发现String是堆空间的主要部分，同时大部分String都是一些拉丁文，一个字节就能够撑得下，如果使用char的话，因为char占两个字节，所以有一半的空间被浪费掉。

所以，由char\[\]改为了byte\[\]，再补一个字符标码集的标识coder；如果是ISO-8859-1、Latin-1就用一个byte去存，如果是UTF-16还是用两个字节去存。

结论：String再也不用char\[\]来存储了，改成了byte\[\]加上编码标记，节约了一些空间。

#### String存储结构发生了变更，StringBuffer和StringBuilder是否改变了？ ####

基于String的类，比如StringBuilder、StringBuffer以及HotSpot虚拟机内部的一些类也进行了修改。

#### 实例（因为String不可变性，原来地址的值是无法被改变的）： ####

![img][]

### 二、String的内存分配 ###

1.在Java语言中有8种基本数据类型和一种比较特殊的类型String。这些类型为了使它们在运行过程中速度更快、更节省内存，都提供了一种常量池的概念。

2.常量池就类似一个Java系统级别提供的缓存。8种基本数据类型的常量池都是系统协调的，String类型的常量池比较特殊。它的主要使用方法有两种。

（1）直接使用双引号声明出来的String对象会直接存储在常量池中。（String a = “aaa”;）

（2）如果不是用双引号声明的String对象，可以使用String提供的intern()方法。

3.Java 6及以前，字符串常量池存放在永久代。

4.Java7中Oracle的工程师对字符串池的逻辑做了很大的改变，即将字符串常量池的位置调整到Java堆内。

所有的字符串都保存在堆（Heap）中，和其他普通对象一样，这样可以让你在进行调优应用时仅需要调整堆大小就可以了。

字符串常量池概念原本使用得比较多，但是这个改动使得我们又足够的理由让我们重新考虑在java7中使用String.intern()。

5.java8永久代变为元空间，字符串常量还是在堆。

![img][img 1]

![img][img 2]

![img][img 3]

#### 为什么要将StringTable进行调整，从永久代->堆？ ####

1.永久代空间有限，将字符串放在永久代容易报OOM-永久代内存溢出。

2.永久代回收频率很低。

### 三、String的基本操作 ###

java语言规范里要求完全相同的字符串字面量，应该包含同样的Unicode字符序列（包含同一份码点序列的常量），并且必须是指向同一个String类实例。

#### 实例1： ####

debug下，可以逐行查看字符串常量池，首次加载1-10之后，再次打印就不会再往字符串常量池里加1-10字符串了：

![img][img 4]

#### 实例2： ####

line3、line4的new的Object()、Memory()都是指向堆空间。

line6的param也指向堆空间Object()。

line7的param的toString()方法返回一个字符串，字符串存在字符串常量池里。

![img][img 5]

### 四、字符串拼接操作 ###

1.常量与常量的拼接结果在常量池，原理是编译期优化。

2.常量池中不会存在相同内容的常量。

3.只要其中有一个是变量，结果就在堆中。变量拼接的原理是StringBuilder。

4.如果拼接的结果调用intern()方法，则主动将常量池中还没有的字符串对象放入池中，并返回此对象地址。

#### 实例1：（常量与常量的拼接结果在常量池） ####

![img][img 6]

反编译结果：

![img][img 7]

#### 实例2：（拼接其中有一个是变量，结果就在堆中，相当于新new的String） ####

intern()方法就是判断字符串常量池中是否存在这个字符串，如果存在则返回常量池中字符串地址，如果不存在就在常量池中加载字符串并返回此地址。

![img][img 8]

#### 实例3：（字符串变量拼接底层是用StringBuilder） ####

根据字节码指令可以看出，拼接字符串变量，先new了StringBuilder，然后使用append操作，然后调用toString()方法。

StringBuilder的toString()方法，约等于new String(“”)。具体继续往下看。

（补充：jdk1.5之后，拼接字符串使用StringBuilder，jdk1.5之前使用StringBuffer）

![img][img 9]

![img][img 10]

#### 实例4： ####

字符串拼接操作，不一定是用的StringBuilder。如果拼接符号左右两边都是字符串常量或者常量引用（final修饰），则仍然使用编译期优化，非StringBuilder方式。

所以，针对于final修饰的类、方法、基本数据类型、引用数据类型的结构时，能使用上final的时候建议使用上。

![img][img 11]

反编译：

![img][img 12]

#### 实例5：练习 ####

![img][img 13]

#### 实例6：多个字符串拼接，其实也只new了一个StringBuilder ####

![img][img 14]

![img][img 15]

#### 实例7：for循环中拼接字符串 ####

可以看出，for每循环一次就会new一个StringBuilder。所以，拼接字符串最好还是直接使用StringBuilder，而不是“+”。

![img][img 16]

![img][img 17]

#### 总结： ####

字符串拼接最好使用StringBuilder调用append来拼接。

使用加号“+”拼接，会new一个StringBuilder，并且在最后调用toString方法时还会new String()。

内存中由于创建了较多的StringBuilder和String对象，还有一方面是内存占用，调用GC还会额外花费时间。

所以，字符串拼接直接使用StringBuilder会大大提高性能，尤其是多个字符串拼接。

改进的空间：

如果开发中基本确定拼接后的字符串长度不高于某个限定值，可以使用StringBuilder(int highlevel)构造器来进行创建StringBuilder。

### 五、intern()的使用 ###

![img][img 18]

以上的解释：

如果字符串常量池中，通过queals方法对比的时候，已经包含了这个字符串，接下来池子中的字符串将会被返回。否则就会将这个字符串加到池子里，并且返回这个字符串实例。

假如说s和t是相同的，以下两种情况结果都为true。

s.intern() == t.intern()

s.equals(t)

1.如果不是用双引号声明的String对象，可以使用String提供的intern方法：intern方法会从字符串常量池中查询当前字符串是否存在，若不存在就会将当前字符串放入常量池中。

比如：String s = new String(“I love you”).intern();

2.也就是说，如果在任意字符串上调用String.intern方法，那么其返回结果所指向的那个类实例，必须和直接以常量形式出现的字符串实例完全相同。因此，下列表达式的值必定是true：

(“a” + “b” + “c”).intern() == “abc”;

3.通俗点讲，Interned String就是确保字符串在内存里只有一份拷贝，这样可以节约内存空间，加快字符串操作任务的执行速度。注意，这个值会被存放在字符串内部池（字符串常量池）（String Intern Pool）。

#### 如何保证变量s指向字符串常量池中的数据？ ####

1.String s = “abc”; // 字面量方式定义。

2.String s = new String(“abc”).intern();

String s = new StringBuilder(“abc”).toString().intern(); //调用intern方法。

#### new String(“abc”)会创建几个对象？ ####

1.创建了两个对象

![img][img 19]

![img][img 20]

一个是通过new关键字在堆空间创建的。

另一个是ldc创建的字符串常量池中的对象。

2.创建了5个对象

![img][img 21]

![img][img 22]

第一个new 了StringBuilder对象（1）。

第二个new了String（4）。

第三个常量池中的a（6）。

第四个new了String（9）。

第五个常量池中的b（11）。

第六个，StringBuilder的toString()方法，也会new一个String（toString方法的调用，并不会将字符串放到字符串常量池中）。

#### StringBuilder的toString()方法： ####

toString方法的调用，并不会将字符串放到字符串常量池中。

我们并没有在字节码指令中发现ldc命令，所以并没有将字符串放到字符串常量中。

![img][img 23]

![img][img 24]

#### 经典题目（99%的人会做错！） ####

![img][img 25]

结果：

jdk6：false、false。

jdk7和8：false、true。

解释：

Strign s = new String(“1”);我们已经知道，它不仅会new一个String对象在堆中，而且还会在字符串常量池中放上"1"。

所以调用s.intern();并没有什么实际意义，因为字符串常量池中已经有"1"了。

而且s指向的是new String(“1”)的地址，而不是常量池中的地址。

如果s.intern() 改为s = s.intern(); 那么s == s2就是true了。

s3的地址记录的实际是new String(“11”)。此时，字符串常量池中并不存在"11"，只存在"1"，因为字符串拼接使用StringBuilder之后调用的toString()方法，并不会将结果存在字符串常量池中。

s3.intern();会将"11"存在字符串常量池中。jdk6中就是创建了一个常量池中新的对象"11"，也就有新的地址；jdk7和8常量池放到堆中了，这里s3调用intern()方法，这里由于空间节省，常量池中并不会创建"11"，而是创建了一个指向堆空间new String(“11”)的地址。

String s4 = “11”; s4指向的地址是上一行代码在常量池中存放的"11"。

jdk7和8中，本质上s3和s4指向了堆中同一个地址。

![img][img 26]![img][img 27]

详细过程：

![img][img 28]

#### 拓展： ####

![img][img 29]

原因：

String s4 = “11”; 是实打实的在字符串常量池中创建了"11"，而不是一个引用了。

s3.intern(); 因为常量池中已经有"11"了。

此时s3指向堆中的new String(“11”); s4指向常量池中的"11"，s5也指向常量池中的"11"。

#### 总结String的intern()的使用： ####

1.jdk1.6中，将这个字符串对象尝试放入字符串常量池。

如果串池中有，则并不会放入，返回已有的串池中的对象的地址。

如果没有，会把此对象复制一份，放入串池，并返回串池中的对象地址。

2.jdk1.7起，将这个字符串对象尝试放入串池。

如果串池中有，则并不会放入，返回已有的串池中的对象地址。

如果没有，则会把对象的引用地址复制一份，放入串池，并返回串池中的引用地址。

#### intern练习1： ####

![img][img 30]

jdk6：true、false

jdk7：true、true（jdk7在串池并没有创建"ab"对象，而是创建了一个引用，指向堆中的new String(“ab”)的地址）

![img][img 31]

![img][img 32]

在代码前面加上String x = “ab”;

![img][img 33]

#### intern练习2： ####

![img][img 34]

第一种情况是false,第二种情况是true。

String s1 = new String(“ab”); 会在堆中new 一个String，并且也会在字符串常量池中新建一个"ab"。

String s1 = new String(“a”) + new String(“b”); 会在字符串常量池中新建"a"、“b”，拼接字符串使用StringBuilder，其toString()方法并不会在常量池中创建"ab"。而且调用s1.intern()之后，jdk7由于堆中已经有ab字符串了，在字符串常量池只创建了一个该对象的引用。

### 六、intern()效率测试 ###

#### 空间角度（jdk1.8） ####

![img][img 35]

使用jvisualvm查看结果：

不使用intern：

![img][img 36]

使用intern：

![img][img 37]

总结：使用intern更节省内存空间（尤其是程序中有大量重复的字符串时），并且执行速度还快。

### 七、StringTable的垃圾回收 ###

使用jvm参数：

![img][img 38]

\-XX:+PrintStringTableStatistics，打印字符串常量池信息。

main函数中什么也不写的字符串常量池打印信息：

![img][img 39]

执行以下代码：

![img][img 40]

![img][img 41]

执行以下代码：

![img][img 42]

我们会发现发生了GC，并且字符串常量池数据量降了下来

![img][img 43]

### **八、G1中的String去重操作** ###

![img][img 44]

1.背景：对许多Java应用（有大的也有小的）做的测试得出以下结果：

堆存活数据集合里面String对象占了25%。

堆存活数据集合里面重复的String对象有13.5%。

String对象的平均长度是45。

2.许多大规模的Java应用的瓶颈在于内存，测试表明，在这些类型的应用里面，Java堆中存活的数据集合差不多25%是String对象。更进一步，这里面差不多一半String对象是重复的，重复的意思是说：string1.equals(string2)=true。堆上存在重复的String对象必然是一种内存的浪费。这个项目将在G1垃圾收集器中实现自动持续对重复的String对象进行去重，这样就能避免浪费内存。

#### **实现** ####

1.当垃圾收集器工作的时候，会访问堆上存活的对象。对每一个访问的对象都会检查是否是候选的要去重的String对象。

2.如果是，把这个对象的一个引用插入到队列中等待后续的处理。一个去重的线程在后台运行，处理这个队列。处理队列的一个元素意味着从这个队列删除这个元素，然后尝试去重它引用的String对象。

3.使用一个hashtable来记录所有的被String对象使用的不重复的char数组。当去重的时候，会查这个hashtable，来看堆上是否已经存在一个一模一样的char数组。

4.如果存在，String对象会被调整引用那个数组，释放对原来的数组的引用，最终会被垃圾收集器回收掉。

5.如果查找失败，char数组会被插入到hashtable，这样以后的时候就可以共享这个数组了。

#### **命令行选项** ####

UseStringDeduplication(bool)：开启String去重，默认是不开启的，需要手动开启。

PrintStringDeduplicationStatistics(bool)：打印详细的去重统计信息。

StringDeduplicationAgeThreshold(uintx)：达到这个年龄的String对象被认为是去重的候选对象。

[img]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/aedc1b496bb24978997371e6e06347bf.png
[img 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/a0df8a6d1fb4487ea280830d1f241e14.png
[img 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/97e8cce77d2d4dd49af4cb543cd9d212.png
[img 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/b3069faf5c0d4dbf9e094f79b383c9df.png
[img 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/9c63ee41554244cf998a90091c6dc846.png
[img 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/ea4d0f1c267043ab8798737cfbac61ef.png
[img 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/f5a7ecb0aa234136a744476b89a49032.png
[img 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/22dea6291f6145c2bf19c5a9d7e07f58.png
[img 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/202b1e09d48b499bad7c99c02cc253e8.png
[img 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/4eadbfb9e35145cf8d2dfdf0cedc48ff.png
[img 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/35c9ced89c644ed5ba31d1af045a9ce8.png
[img 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/f2b5b8e1c4984686a1c4ea8c8a92053b.png
[img 12]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/bfdfb82847bf4fbaa384777cf82263ae.png
[img 13]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/aec2dbea00d9428bad4fd1ac6d9629ff.png
[img 14]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/fd283300de56464b9c83bfe9e464e664.png
[img 15]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/48ee619f73d747c9a172aee4178cdb92.png
[img 16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/369b0e26dd024f139e5d397f9ec34138.png
[img 17]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/8171ea6a9f4b4773bdecbb428f9fc013.png
[img 18]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/46f8954b82a245af88c69a6fe1eb5a9f.png
[img 19]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/d8f8628b483b4962a89d70da8924fa3d.png
[img 20]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/e12d03c11a5e4933a1b1fb2468ce90b6.png
[img 21]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/fa3a48d9abc74a6191b265afef545b9c.png
[img 22]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/9d5e7e73fc624f96a87a2e08d0d30c21.png
[img 23]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/f00a7fce65f94c32a9d61210fb388738.png
[img 24]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/ede0d047060f4d9497c8115132ea7101.png
[img 25]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/40677ffb839f48dfad90f18680ead69b.png
[img 26]: https://img-blog.csdnimg.cn/20210718163926902.png
[img 27]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/acabfe69e48e45cb984d8293dd39da7c.png
[img 28]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/eac70b6db0e04e0fbdf05819c5001c41.png
[img 29]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/6b6a0d35aebe4064a43ca511bf77a630.png
[img 30]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/dcca0149d972447ba4571c43b4e95034.png
[img 31]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/4362c1f5826c4d3c9cd258e088614599.png
[img 32]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/e11b18c245ae4061b4369176deebf644.png
[img 33]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/827c1be847044b4eaa013f5912896f64.png
[img 34]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/9eb0ec6a06f94cb9a8e5a52a9d9540ef.png
[img 35]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/ae6d34625d99429eaeaa226179366c80.png
[img 36]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/a2a3eb4143234256a986f5122ea123de.png
[img 37]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/95e2ca88b4a544398d41c4bda874d4e7.png
[img 38]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/c69ea2ee611041339b9ebee76b7fcc0f.png
[img 39]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/802bff08ddc44b8b992a3bf7b39312ac.png
[img 40]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/b14075078004479085f5e3cebb04ffff.png
[img 41]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/65d99c0c96a3423f872aba111e37e22f.png
[img 42]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/9b30886fdf7641f79f31e0c20e2e4eda.png
[img 43]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/583eb038f4b64d1caa0454b7e15ac537.png
[img 44]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/e077aeb597284d0c96640b700df81b9b.png