JVM-12(String Table)

12.1 📖 概述

🌠 基本特性

String字符串使用一对””引起来表示。
String声明为final，不可被继承。
String实现了Serializable接口：表示字符串是支持序列化的。
String实现了Comparable接口，表示String可以比较大小。
String在jdk8及以前内部定义了final char[] value用于存储字符串数据。jdk9时改为byte[]

❔ String存储结构变更的原因

JDK8及以前中String类的实现将字符存储在char数组中，每个字符占用两个字节。从许多不同的应用程序收集的数据表明，字符串是堆使用的主要组成部分，而且，大多数字符串对象只包含拉丁字符。这些字符只需要一个字节的存储空间，因此这些字符串对象的内部char数组中有一半的空间将不会使用。

JDK9将String内部表示从UTF-16的char数组改为byte数组+编码标志字段。新的String类将根据字符串的内容存储编码为ISO-8859-1/Latin-1(每个字符一个字节)或UTF-16(每个字符两个字节)的字符。编码标志将指示使用哪种编码。

总结：String由char[]+UTF-16改为byte[]+encoding-flag，节约了一些空间。

🔘 不可变性

当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串声明在字符串常量池中。

👁‍🗨 字符串常量池

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

String的String Pool是一个固定大小的HashTable，默认值大小长度是1009。如果放进String Pool的String非常多，就会造成Hash冲突严重，从而导致链表会很长，而链表长了后直接会造成的影响就是当调用String.intern时性能会大幅下降。
使用-XX:StringTableSize可设置StringTable的长度
在JDK6中StringTable是固定的。就是1009的长度，所以常量池中的字符串过多就会导致效率下降很快。StringTableSize设置没有要求。
在JDK7中，StringTable的长度默认值是60013。
JDK8开始，设置StringTable的长度的话，1009是可设置的最小值。

12.2 🌌 内存分配

💬 说明

在Java语言中有8中基本数据类型和一种比较特殊的类型String。这些类型为了使它们在运行过程中速度更快、更节省内存，都提供了一种常量池的概念。
常量池就类似一个Java系统级别提供的缓存。8种基本数据类型的常量池都是系统协调的，String类型的常量池比较特殊。它的主要使用方法有两种：一种是使用字面量声明，另一种是使用String.intern()方法。
在JDK6及以前，字符串常量池存放在永久代(PermGen)。
Java7中Oracle的工程师对字符串池的逻辑做了很多的改变，即将字符串常量池的位置调整到Java堆内。
- 所有的字符串都保存在堆（Heap）中，和其他普通对象一样，这样可以让你在进行调优应用时仅需要调整堆大小就可以了。
- 字符串常量池概念原本使用得比较多，但是这个改动使得我们有足够的理由让我们重新考虑在Java 7中使用String.intern()。
Java8元空间，字符串常量池在堆。

❔ StringTable调整内存位置的原因

PermSize默认比较小
永久代垃圾回收频率低

12.3 🛠️ 字符串操作

🎗️ 字符串拼接

常量与常量的拼接结果在常量池，常量拼接的原理是编译期优化。
常量池中不会存在相同内容的常量。
只要有一个是变量，结果就在堆中。变量拼接的原理是StringBuilder。
如果拼接的结果是调用intern()方法，则主动将常量池中还没有的字符串对象放入池中，并返回此对象地址。

🔍 查看底层

Java代码：

@Test
void test5() {
    String s1 = "a";
    String s2 = "b";
    String s3 = "ab";             // 字符串常量池
    String s4 = s1 + s2;          // 堆空间
    System.out.println(s3 == s4); // false
}

反编译：

 0 ldc #3 <a>  // 将a从运行时常量池中压入操作数栈
 2 astore_1    // 将a存放在局部变量表索引为1的位置
 3 ldc #17 <b> // 将b从运行时常量池中压入操作数栈
 5 astore_2    // 将b存放在局部变量表索引为2的位置
 6 ldc #18 <ab>// 将ab从运行时常量池中压入操作数栈
 8 astore_3    // 将ab存放在局部变量表索引为3的位置
 9 new #19 <java/lang/StringBuilder> // new一个StringBuilder
12 dup         // 复制操作操作数栈顶的StringBuilder的引用
13 invokespecial #20 <java/lang/StringBuilder.<init>> // 调用StringBuilder的初始化方法
16 aload_1     // 从局部变量表索引为1的位置装载一个对象引用(a)到操作数栈顶
17 invokevirtual #21 <java/lang/StringBuilder.append> // 调用StringBuilder的append方法，连接a
20 aload_2     // 从局部变量表索引为2的位置装载一个对象引用(b)到操作数栈顶
21 invokevirtual #21 <java/lang/StringBuilder.append> // 调用StringBuilder的append方法，连接b
24 invokevirtual #22 <java/lang/StringBuilder.toString> // 调用StringBuilder的toString方法，将该字符串放在堆中，引用放在操作数栈中
27 astore 4    // 将ab存放在局部变量表索引为4的位置
---

字符串拼接，JDK5.0之前使用的是StringBuffer，JDK5.0之后使用的是StringBuilder。

关键就在于toString()方法，可以看一下源代码：

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

// StringBuffer
@Override
public synchronized String toString() {
    if (toStringCache == null) {
        toStringCache = Arrays.copyOfRange(value, 0, count);
    }
    return new String(toStringCache, true);
}

可以看到，两个方法中均采用了new String()的方法。因此对于非字面量的拼接操作，都在堆中new了一个String对象。

⌨️ ==测试

@Test
void test4() {
    String s1 = "a" + "b" + "c";         // 编译器优化，拼接结果存放在字符串常量池中
    String s2 = "abc";                   // 字符串常量池中不存放相同的字符串
    System.out.println(s1 ==s2);         // true
    System.out.println(s1.equals(s2));   // true
}

@Test
void test5() {
    String s1 = "a";
    String s2 = "b";
    String s3 = "ab";
    String s4 = s1 + s2;
    System.out.println(s3 == s4);        // false
}

@Test
void test6() {
    String s1 = "boot";
    String s2 = "cloud";
    String s3 = "boot" + "cloud";        // 字符串拼接结果放在字符串常量池中
    String s4 = s1 + "cloud";            // 带变量的拼接结果放在堆中
    String s5 = "boot" + s2;             // 带变量的拼接结果放在堆中
    String s6 = s1 + s2;                 // 带变量的拼接结果放在堆中
    System.out.println(s3 == s4);        // flase
    System.out.println(s3 == s5);        // flase
    System.out.println(s3 == s6);        // flase
    System.out.println(s4 == s5);        // flase
    // intern(): 判断字符串常量池中是否存在"bootcloud"值
    // 如果存在，则返回字符串常量池中"bootcloud"的地址；
    // 如果不存在，则在字符串常量池中添加一次"bootcloud"，并返回此对象的地址
    String s7 = s5.intern();
    System.out.println(s3 == s7);        // true
}

@Test
void test7() {
    final String s1 = "c";               // 常量
    final String s2 = "d";               // 常量
    String s3 = "cd"; 
    String s4 = s1 + s2;                 // 拼接符合左右两边都是字符串常量或者常量引用，仍然使用编译期优化
    System.out.println(s3 == s4);        // true
}

⌨️ 效率测试

public class StringAppendTest {

    @Test
    void test1() {
        String str = "";
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            str = str + "k";
        }
        long end = System.currentTimeMillis();
        System.out.println("String拼接花费时间：" + (end - start) + "ms"); // 3935ms
    }

    @Test
    void test2() {
        StringBuilder sb = new StringBuilder(100000);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            sb.append("k");
        }
        long end = System.currentTimeMillis();
        System.out.println("StringBuilder拼接花费时间：" + (end - start) + "ms"); // 3ms
    }
}

效率：

StringBuilder的appendAPI >> String的字符串拼接

原因：

(1) StringBuilder方式自始至终只创建一个StringBuilder对象，String拼接会创建多个StringBuilder对象。

(2) 使用String字符串拼接，内存中由于创建了多个StringBuilder和String对象,会增加GC的频率，影响执行效率。

改进：

StringBuilder无参创建的数组空间是16，如果实际开发中长度大于16，则需要不断进行数组扩容。

如果明确拼接后的字符串长度不高于某个限定值highLevel，在定义StringBuilder的时候即可赋予响应空间，即new StringBuilder[highLevel]。

💡 intern()方法

美团技术团队沙龙-intern：https://tech.meituan.com/2014/03/06/in-depth-understanding-string-intern.html

intern是一个native方法，调用的是底层C语言实现的方法。

JDK1.8的API说明：字符串池最初是空的，由String类私有地维护。在维护intern方法时，如果池中已经包含了由equals(object)方法确定的与该字符串对象相等的字符串，则返回池中的字符串。否则，该字符串对象将被添加到池中，并返回对该字符串对象的引用。如果不是用双引号声明的string对象，可以使用string提供的intern方法：intern方法会从字符串常量池中查询当前字符串是否存在，若不存在就会将当前字符串放入常量池中。

在JDK1.6中，String.intern()方法尝试将字符串放入字符串常量池，如果没有，会把此对象复制一份，放入字符串常量池，并返回字符串常量池中的对象地址。

自JDK1.7起，String.intern()方法尝试将字符串放入字符串常量池，如果没有，会把此对象的引用地址复制一份，放入字符串常量池，并返回字符串常量池中的引用地址。

至于更改原因，也不必多说了，之前是需要创建一个新的对象放在字符串常量池中，现在是存放一个堆空间中的引用，当然更加节省空间。

对于需要大量使用相同字符串的网站平台，建议使用intern保存到字符串常量池中，以节省内存空间。

12.4 ❓ 面试题

1️⃣ new String(“ab”) 会创建几个对象？

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

前者创建了两个对象：

第一个是new 关键字在堆空间创建的对象
第二个是在字符串常量池中创建的字符串的引用（指向堆空间的地址）

后者创建了六个对象：

对象1：new StringBuilder()
对象2：new String(“a”)
对象3：字符串常量池中a的引用
对象4：new String(“b”)
对象5：字符串常量池中b的引用
深入剖析
- 对象6：StringBuilder的toString方法中创建的new String(“ab”)
- 注意，toString方法的调用没有在常量池中生成字符串的引用

2️⃣ 下列代码的执行结果是？

public class StringInternTest {
 public static void main(String[] args) {
     String s1 = new String("1");
     s1.intern(); 
     String s2 = "1";
     System.out.println(s1 == s2); 

     String s3 = new String("1") + new String("1");
     s3.intern();
     String s4 = "11";
     System.out.println(s3 == s4); 
 }
}

结果：

JDK6: false false
JDK7/8: false true

解析：

String s1 = new String("1");
// s1是堆空间中创建的"1"的地址
s1.intern();
// 调用此方法之前，字符串常量池已经存在了"1"
String s2 = "1";
// s2是字符串常量池中"1"的地址
System.out.println(s1 == s2);
// JDK1.6: false; JDK1.7/1.8: false

String s3 = new String("1") + new String("1");
// s3是StringBuilder的toString方法new String("11")在堆空间中的地址，
// 但是toString的new String并没有把"11"放入字符串常量池
s3.intern();
// jdk1.6会复制一个堆空间中的"11"对象，即创建新的对象，放入字符串常量池（全新地址）
// jdk1.7/1.8会复制一个堆空间中的"11"对象的引用地址，放入字符串常量池（引用地址）
String s4 = "11";
// s4是字符串常量池中"11"的对象地址
System.out.println(s3 == s4);
// JDK1.6: false; JDK1.7/1.8: true