JVM内存结构之——常量池

常量池（Constant Pool）

1.1 常量池（Class文件常量池）：.java经过编译后生成的.class文件，是Class文件的资源仓库。

Java源代码 编译成 class

常量池分类：

• 运行时常量池 :类加载器读取class文件到内存中，该常量池就是运行时常量池，JDK8 存放在方法区
• 静态常量池 :java 编译 class 还没有被类加载器加载该class文件
• 字符串常量池: JDK7之前存放在方法区中，JDK 7、 JDK 8中存放在堆中，

字符串常量池还是存放在我们堆中。

1.2 常量池中主要存放：字面量（文本字符串，final常量）和符号引用（类和接口的全局定名，字段的名称和描述，方法的名称和描述）

• 常量池：通过一张表，虚拟机根据该常量表扎到执行的类名、方法名、参数类型、字面量。
  javap -verbose中或者javap -v class文件名称

二. 常量池的分类

静态常量池、字符串常量池、运行时常量池

2.1 静态常量池

class文件中除了包含类的版本、字段、方法、接口等描述信息外，还有一项信息就是常量池(constant pool table)，用于存放编译器生成的各种字面量(Literal)和符号引用(Symbolic References)。 字面量就是我们所说的常量概念，如文本字符串、被声明为final的常量值等。 符号引用是一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可（它与直接引用区分一下，直接引用一般是指向方法区的本地指针，相对偏移量或是一个能间接定位到目标的句柄）。一般包括下面三类常量：

类和接口的全限定名
字段的名称和描述符
方法的名称和描述符

2.2. 运行常量池

而运行时常量池，则是jvm虚拟机在完成类装载操作后，将class文件中的常量池载入到内存中，并保存在元空间中，我们常说的常量池，就是指方法区中的运行时常量池。

2.3. 字符串常量池

JDK1.7之前，运行时常量池（字符串常量池也在里边）是存放在方法区，此时方法区的实现是永久带。
JDK1.7字符串常量池被单独从方法区移到堆中，运行时常量池剩下的还在永久带（方法区）
JDK1.8，但字符串常量池池还在堆中，运行时常量池在元空间（方法区）。

三. 如何证明字符串常量池是存放在堆中

JDK7开始 字符串常量池 存放在堆中

5.1 JDK1.8字符串常量池存放在堆中

public class StringDemo020 {
    // JDK1.8 设置 堆内存大小 -Xmx1m -Xms1m  -XX:-UseGCOverheadLimit
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        int count = 0;
        try {
            for (int i = 0; i < 250000; i++) {
                arrayList.add((i + "").intern());
                count++;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("循环次数:" + count);
        }
    }
}

JDK1.6字符串常量池存放在方法区
测试代码：

    // jdk1.6 设置 方法区大小参数:-XX:MaxPermSize=1m
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        int count = 0;
        try {
            for (int i = 0; i < 2500000; i++) {
                arrayList.add((i + "").intern());
                count++;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("循环次数:" + count);
        }
    }
}

Exception in thread “main” java.lang.OutOfMemoryError: PermGen space

四、字符串常量池存放的是什么？

首先说结论：字符串堆中的字符串常量池存放字符串和字符串引用

这是常量池也叫class常量池，字符串常量池因为其使用频率高的特殊性，jvm为其划分了一块特殊区域

所以字符串常量池包含的内容和class常量池的内容有所区别，我们看下图

字符串常量池中存放直接引用
那么什么是符号引用什么是直接引用呢？

• 符号引用：符号引用就是一个类中（当然不仅是类，还包括类的其他部分，比如方法，字段等）引入了其他的类，可是JVM并不知道引入的其他类在哪里，所以就用唯一符号来代替，等到类加载器去解析的时候，就通过符号引用找到那个引用类的地址，这个地址也就是直接引用。
• 直接引用：直接引用是和虚拟机的布局相关的，同一个符号引用在不同的虚拟机实例上翻译出来的直接引用一般不会相同。如果有了直接引用，那引用的目标必定已经被加载入内存中了。

直接引用可以是：
（1）直接指向目标的指针（比如，指向“类型”【Class对象】、类变量、类方法的直接引用可能是指向方法区的指针）
（2）相对偏移量（比如，指向实例变量、实例方法的直接引用都是偏移量）
（3）一个能间接定位到目标的句柄

4.1 为什么说存放引字符串和字符串引用？

    首先就我们必须得清楚，字符串对象在jvm中存放的位置：字符串常量池和堆内存
    简要概述：
    String a = "a";时字符串对象存在于字符串常量池，此时String类提供一个API：intern()，这个API可以手动将一个字符串对象的值转移到字符串常量池中，它是一个native方法，

在Hotspot JVM里字符串常量池它的逻辑在注释里写得很清楚：
①.如果常量池中有这个字符串常量，就直接返回，否则将该字符串对象的值存入常量池，再返回
①.那么此时我们能确定字符串对象存在于常量池中

String b = new String(“a”)，这个代码大家不陌生，面试中也常问到这段代码创建了几个对象。那么他是如何运行的呢？
②.如果字符串常量池先前已创建出该字符串对象，则返回池中的该字符串的引用。否则，若该字符串对象已经存在于 Java 堆中，则将堆中对此对象的引用添加到字符串常量池中，然后返回该引用；如果堆中不存在，则在池中创建该字符串并返回其引用
②.那么此时我们能确定字符串引用存在于常量池中

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

一、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不可变性，原来地址的值是无法被改变的）：

二、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永久代变为元空间，字符串常量还是在堆。

2.1字符串创建

String str1 = "hello,mrz";

这种方式会直接将字符串放到字符串常量池中:

注意：在JDK1.7之后(包括1.7)，字符串常量池已经从方法区移动到了堆区

当我们再次通过字面量声明一个内容相同的字符串时，不会新建对象，而是直接指向池中的地址，如下图：

方式二:new String()

String str2 = new String("hello,mrz");

使用这种方式创建字符串，要分两种情况：

1. 如果字符串常量池中已经存在了相同内容的字符串对象,只创建一个对象(比如在new之前已经用字面量声明的方法创建了一个相同内容的字符串)

解释:

1、"abc"是字符串常量，应该在常量池中创建，JVM在常量池中检查发现已经存在有相同内容的字符串，所以不再创建
2、遇到new关键字，会在堆中创建一个String对象，返回给str2

2. 如果字符串常量池中不存在相同内容的常量

1、首先在字符串常量池创建一个"hello,mrz"对象
2、遇到new关键字，在堆中创建一个字符串对象，返回给str2

1.3、比较以上两种方式可以得到:

1、通过字面量声明的方式最多创建一个对象，最少不创建对象

• 如果常量池中没有，创建一个对象
• 如果常量池中已经存在，不创建对象，直接引用
  2、通过new String()方式最少创建一个对象，最多创建两个对象
• 如果常量池中没有，在常量池中创建一个对象，在堆中创建一个对象
• 如果常量池中已经存在，则只会在堆中创建一个对象
• 绝对会在堆中创建一个字符串对象，常量池中可能创建可能不创建

扩展

Strin str = new String(“a”) + new String(“b”) 创建了几个对象?

一共创建了5个对象

解释:

在常量池中创建了2个字符串对象:a"字符串对象，"b"字符串对象
在堆中创建了三个字符串对象:"a"字符串对象，"b"字符串对象，"ab"字符串对象

注意:拼接是在堆中完成的，这里实际上是使用 StringBuilder.append 来完成字符串的拼接, 所以在堆内存中会存在一个 “ab”, 但是在字符串常量池中没有 “ab” 。如果要入池需要使用后文的intern()方法

2.2、字符串比较相等

String str1 = "Hello";
String str2 = "Hello"; 
System.out.println(str1 == str2); //true

至于例一为什么这为true不再赘述，看1.1内存图便可明白：str1和str2指向字符串常量池中同一个地址，固然相等

String str1 = new String("Hello,mrz");
String str2 = new String("Hello,mrz");
System.out.println(str1 == str2); //false

解释：new关键字都是在堆中开辟内存创建对象的，所以肯定地址肯定不同，也就是为false

可是我们想要的效果是：“只要两个字符串内容相同，就为true”；怎么办呢？那就要使用equals()方法进行判断了

2.2.1、equals()方法

记住一句话:

使用 == 比较的是两个引用是否指向同一个地址(“身份”是否相同)，比较字符串的内容是否相等要使用equals方法

所以在2.1-例二中，如果是str1.equals(str2)，那么结果就是true

对于自定义的类，如果要比较两个对象的内容是否相同,一定要重写equals()方法

假如现在要比较str和"hello"内容是否相等，推荐下面这种写法:

"hello".equals(str);
str.equals("hello");
//第二种可能会NullPointerException,第一种永远不会

2.3、String.intern()

先来看看intern()方法的介绍:

在jdk1.7之前

1. 如果池中有相同内容的字符串，则直接返回池中该字符串的引用(地址)
   2.如果池中没有相同内容的字符串，则会把堆中这个字符串对象拷贝一份，放入常量池,然后返回池中字符串对象的引用

在jdk1.7之后(包含1.7) <1>如果池中有相同内容的字符串，则直接返回池中该字符串的引用

<2>如果池中没有，则会把这个字符串对象的的地址复制一份，放入池中，并返回池中的引用(指向堆中的字符串对象)

3.2、可能文字并不好解释清楚，接下来我将通过几个案例演示(以jdk1.7为准)

String str1 = new String("hello,mrz");
String str2 = "hello,mrz";
str1.intern();
System.out.println(str1 == str2);//false

解释:

new String(“hello,mrz”),首先在池中创建一个"hello,mrz"对象，然后在堆中创建了字符串对象引用池中对象，返回堆中对象的引用给str1

str2直接引用池中对象的0x444

str1.intern()入池，JVM检测到池中已有相同内容的字符串，返回池中字符串的引用，但这里没有接收，str1还是指向堆中的对象

所以为false

//上述代码中，如果改成
str1 = str1.intern();
//str1接收到返回值，也指向池中对象，那么就是true

案例二：

String str1 = new String("hello") + new String(",mrz");
String str2 = "hello,mrz";
str1.intern();
System.out.println(str1 == str2);//false

解释：

执行第一句:new String(“hello”)+new String(“,mrz”)

在堆中创建了"hello"对象、“,mrz"对象，在常量池中创建了"hello"对象和”,mrz"对象

然后A对象(上图中)和B对象进行拼接，在堆中出现了"hello,mrz"对象

此时常量池中有"hello",“,mrz”,堆中有A、B、C三个对象(拼接底层使用的是 StringBuilder.append 来完成的, 所以在堆内存中会存在一个 “hello,mrz”对象, 但是在字符串常量池中没有 “hello,mrz”)

执行第二句:str2=“hello,mrz”

因为池中没有"hello,mrz",所以会在池中创建一个"hello,mrz"对象，返回引用给str2

执行第三句:str1.intern()

入池，JVM检查发现池中已有相同内容的字符串，则返回池中对象的引用，这里同案例一，也是因为没有接收，所以str1还是指向堆中的对象

所以str1肯定不等于str2

案例三：

但是如果我们调换一下第二、第三句代码的顺序呢？这时候答案就为true了!!!
解释：

第一句代码执行结果同案例二;

第二句str1.intern()入池

此时第三句代码还未执行，池中还没有"hello,mrz"对象,当JVM检查发现池中没有相同内容对象时，就会把堆中C对象的引用复制一份放到池中，然后返回池中的引用地址(就是C的引用)

第三句执行str2=“hello,mrz”

JVM检查发现池中已经有了，则返回常量池中的引用(即str2也是指向C对象)

所以str1和str2都是指向C对象，那么就是true了

综上所述:new String(“a”) + new String(“b”)一共创建了5个对象(池中没有"a"和"b"的前提向下),堆中三个，池中两个
案例四：

2.4、如何理解字符串是不可变的？

4.1、看以下代码

String s1 = "East";
s1 = "South";

s1="South"是直接将s1的内容"East"修改为了"West"吗？
不是!

通过查看String类的源代码可以知道:

String底层是用了一个private final修饰的字符数组:

• private修饰，表明外部类是访问不到value数组的，同时子类也无法访问
• final修饰的内容是不可以被改变的，所以对String来说,一旦初始化，value[]将无法再被修改
• 但是注意，通过反射可以打破封装，可以修改value[]

有人就会说：String既然不可变，那为什么String类还有很多方法都能操作字符串？
其实String类中的很多方法，如toLowerCase，都不是在原来的字符串上进行操作的，而是重新new了个字符串,返回的是新创建的字符串对象

为什么要求字符串不可变?

方便实现字符串对象池. 如果 String 可变, 那么对象池就需要考虑何时深拷贝字符串的问题了. 不可变对象是线程安全的.
不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap 中.

2.5 字符串拼接优化

String str1 = "hellomrz";
String str2 = "hello" + "mrz";
System.out.println(str1 == str2);//true

第一：在池中创建对象"hello,mrz"
第二：编译器在编译时发现"hello" 和 "mrz"都是字符串，会自动进行拼接成"hellomrz"再存储
第三：拼接后存储时，JVM检测到常量池中已有"hellomrz",所以str2会直接引用常量池中的"hellomrz"
故str1中存的地址和str2相同，所以为true

String s1 = "hellomrz";
String s2 = "hello";
String s3 = s2 + "mrz";
System.out.println(s1 == s3);//false

为什么是false呢？首先我们需要先来了解常量和变量的区别:

简但来说:变量只有在运行时才知道其中存储的内容，而常量是在量是在编译时就已经知道存的多少

这里s2就是个变量，编译器在编译时并不知道s2是多少;所以s3在编译时也就是个变量，拼接时在堆中new一个"hello,mrz"对象，返回给s3；s1引用常量池中的"hello,mrz"，两者当然不同

String  s1 = "hellomrz";
final String s2 = "hello";
String s3 = s2 + "mrz";
System.out.println(s1 == s3);//true

相比于5.2，这里s2用final修饰，结果就变为了true

首先我们需要了解的是:对于常量，编译器在编译时就会帮我们进行运算!

例如final修饰的两个int变量，进行相加，编译器在编译时就帮我相加了，即在编译时c就已经等于30，具体可以用javap命令反汇编验证:

final int a = 10;
final int b = 20;
int c = a + b;//c=30

Code:
      0: bipush        10//a
      2: istore_1			
      3: bipush        20//b
      5: istore_2			
      6: bipush        30//c	编译时就已经知道c=30了
      8: istore_3	

所以final修饰的s2也是常量!

那么s2 + "mrz"相当于 “hello” + “mrz”,编译时就优化成"hello,mrz"存储；JVM检测到池中已有相同内容的对象，就返回池中对象的引用，所以s1 == s3;

2. 6、StringBuilder和StringBuffer

StringBuilder和StringBuffer大部分功能都是相同的，两者主要的区别就是StringBuffer是线程安全的，而StringBuilder是非线程安全的;后文以StringBuilder举例，StringBuffer同理

String和StringBuilder的区别？

String和StringBuilder最大的区别在于：String的内容无法修改，如果改变对象的内容，改变的其实是其引用的指向而已;而StringBuilder的内容可以修改

2. 7 String进行拼接的原理是什么

public static void main(String[] args) {
        String str = "hello";
        for (int i = 0; i < 10; i++) {
            str = str + i;
        }
        System.out.println(str);//hello0123456789
    }

​ <2>使用javap进行反汇编:

从图中可以看到，String在进行拼接时，首先会构造一个StringBuilder对象，然后调用其append()方法进行拼接，拼接完成后又调用其toString()方法赋值给str，这样str就完成了"一次拼接";因为使用了for循环，所以第33行时"goto 5",回到第五行重新往下执行，又会重复一遍前面的步骤，直到结束循环退出循环

综上所述:每拼接一次，都会在底层new一个StringBuilder对象,如果在一个程序中反复需要拼接字符串，那么就会在堆中产生大量的StringBuilder对象,浪费内存

StringBuilder拼接是什么样的？

public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("hello");
        for (int i = 0; i < 10; i++) {
            sb.append(i);
        }
        String str = sb.toString();
        System.out.println(str);
    }

可以看到，虽然都是for循环拼接了10次，但是使用String拼接构建了10个StringBuilder对象，而使用StringBuilder拼接只创建了一个StringBuilder对象!!!(在17-32行循环并没有创建新的StringBuilder对象)

综合可得:如果在程序中经常有拼接操作，我们应该选用StringBuilder,
如果需要线程安全的，那应该选用StringBuffer,使用String进行拼接效率太低

2.8 String类一些方法注意事项

String类的两种构造方法使用

No	方法名	类型	概述
1	String(char[] value)	构造	以字符数组构建字符串
2	String(byte[] bytes)	构造	以字节数组构建字符串

可以看到，通过char数组或byte数组都可以构建一个新的字符串，那我们怎么选择呢？

byte[] 是把 数据按照一个字节一个字节的方式处理, 这种方式适合在网络传输, 数据存储这样的场景下使用. 更适合针对二进制数据来操作.
char[] 是把数据按照一个字符一个字符的方式处理, 更适合针对文本数据来操作, 尤其是包含中文的时候

2.9、字符串拆分

No	方法名	类型	概述
1	String[] split(String regex)	成员方法	全部拆分
2	String[] split(String regex,int limit)	成员方法	拆分成limit组

String str = "hello world hello mrz" ; 
String[] result = str.split(" ") ; // 按照空格拆分
for(String s: result) { 
 System.out.println(s); 
}
//"hello"	"world"  "hello"	"mrz"

/... 
String[] result = str.split(" ", 3) ; // 按照空格拆分成三组
/...
//输出: "hello"	"world"	 "hello mrz"

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

1.永久代空间有限，将字符串放在永久代容易报OOM-永久代内存溢出。
2.永久代回收频率很低。

三、String的基本操作

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

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

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

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

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

四、字符串拼接操作

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

字符串拼接原理

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

反编译结果：

实例2：（拼接其中有一个是变量，结果就在堆中，相当于新new的String）
intern()方法就是判断字符串常量池中是否存在这个字符串，如果存在则返回常量池中字符串地址，如果不存在就在常量池中加载字符串并返回此地址。

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

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

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

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

反编译：

实例5：练习

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


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


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

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

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

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

改进的空间：

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

五、intern()的使用

以上的解释：

如果字符串常量池中，通过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.创建了两个对象

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

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

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

第二个new了String（4）。

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

第四个new了String（9）。

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

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

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


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

结果：

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指向了堆中同一个地址。

详细过程：

拓展：

原因：

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

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

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

总结String的intern()的使用：
1.jdk1.6中，将这个字符串对象尝试放入字符串常量池。

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

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

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

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

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

jdk6：true、false

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

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

intern练习2：

第一种情况是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）

使用jvisualvm查看结果：

使用intern：

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

七、StringTable的垃圾回收

使用jvm参数：

-XX:+PrintStringTableStatistics，打印字符串常量池信息。
main函数中什么也不写的字符串常量池打印信息：

执行以下代码：

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

八、G1中的String去重操作

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对象被认为是去重的候选对象。