intern ⽅法

目录：

1. 字符串常量池
2. intern() 方法
3. 实例

1、字符串常量池

String s = new String("二哥");

这行代码创建了几个对象？

两个。使用 new 关键字创建一个字符串对象时，Java 虚拟机会先在字符串常量池中查找有没有'二哥'这个字符串对象，如果有，就不会在字符串常量池中创建'二哥'这个对象了，直接在堆中创建一个'二哥'的字符串对象，然后将堆中这个'二哥'的对象地址返回赋值给变量 s。如果没有，先在字符串常量池中创建一个'二哥'的字符串对象，然后再在堆中创建一个'二哥'的字符串对象，然后将堆中这个'二哥'的字符串对象地址返回赋值给变量 s。

为什么要先在字符串常量池中创建对象，然后再在堆上创建呢？

由于字符串的使用频率实在是太高了，所以 Java 虚拟机为了提高性能和减少内存开销，在创建字符串对象的时候进行了一些优化，特意为字符串开辟了一个字符串常量池。

通常情况下，我们会采用双引号的方式来创建字符串对象，而不是通过 new 关键字的方式：

String s = "三妹";

当执行 String s = "三妹" 时，Java 虚拟机会先在字符串常量池中查找有没有“三妹”这个字符串对象，如果有，则不创建任何对象，直接将字符串常量池中这个“三妹”的对象地址返回，赋给变量 s；如果没有，在字符串常量池中创建“三妹”这个对象，然后将其地址返回，赋给变量 s。

有了字符串常量池，就可以通过双引号的方式直接创建字符串对象，不用再通过 new 的方式在堆中创建对象了。

new 的方式始终会创建一个对象，不管字符串的内容是否已经存在，而双引号的方式会重复利用字符串常量池中已经存在的对象。

来看下面这个例子：

String s = new String("二哥");
String s1 = new String("二哥");

按照我们之前的分析，这两行代码会创建三个对象，字符串常量池中一个，堆上两个。

再来看下面这个例子：

String s = "三妹";
String s1 = "三妹";

这两行代码只会创建一个对象，就是字符串常量池中的那个。这样的话，性能肯定就提高了！

字符串常量池在内存中的什么位置呢？

在 Java 8 之前，字符串常量池在永久代中。

Java 8 之后，移除了永久代，字符串常量池就移到了堆中。

方法区，永久代和元空间的概念

• 方法区是 Java 虚拟机规范中的一个概念，就像是一个接口吧；
• 永久代是 HotSpot 虚拟机中对方法的一个实现，就像是接口的实现类；
• Java 8 的时候，移除了永久代，取而代之的是元空间，是方法区的另外一个实现。

永久代是放在运行时数据区中的，所以它的大小受到 Java 虚拟机本身大小的限制，所以 Java 8 之前，会经常遇到 java.lang.OutOfMemoryError: PremGen Space 的异常，PremGen Space 就是方法区的意思；而元空间是直接放在内存中的，所以只受本机可用内存的限制，虽然也会发生内存溢出，但出现的几率相对之前就小了很多。

---

2、intern() 方法

public native String intern();

1. 使用双引号声明的字符串对象会保存在字符串常量池中。
2. 使用 new 关键字创建的字符串对象会先从字符串常量池中找，如果没找到就创建一个，然后再在堆中创建字符串对象；如果找到了，就直接在堆中创建字符串对象。
3. 针对没有使用双引号声明的字符串对象来说，就像下面代码中的 s1 那样：

String s1 = new String("二哥") + new String("三妹");

如果想把 s1 的内容也放入字符串常量池的话，可以调用 intern() 方法来完成。

intern()是一种手动将字符串加入常量池中的方法，其优点是执行速度非常快，直接使用==进行比较要比使用equals()方法快很多；内存占用少。但是intern()方法每次操作都需要与常量池中的数据进行比较，查看常量池中是否存在等值数据，所以其主要适用于有限值，并且这些有限值会被重复利用的场景，这样可以减少内存消耗，同时在进行比较操作时减少时耗，提高程序性能。

不过，需要注意的是，Java 7 的时候，字符串常量池从永久代中移动到了堆中，虽然此时永久代还没有完全被移除。Java 8 的时候，永久代被彻底移除。

这个变化也直接影响了 String.intern() 方法在执行时的策略，Java 7 之前，执行 String.intern() 方法的时候，不管对象在堆中是否已经创建，字符串常量池中仍然会创建一个内容完全相同的新对象；Java 7 之后呢，由于字符串常量池放在了堆中，执行 String.intern() 方法的时候，如果对象在堆中已经创建了，字符串常量池中就不需要再创建新的对象了，而是直接保存堆中对象的引用，也就节省了一部分的内存空间。

---

3、实例

例 1：

String s1 = new String("二哥三妹");
String s2 = s1.intern();
System.out.println(s1 == s2);

第一行代码，字符串常量池中会先创建一个“二哥三妹”的对象，然后堆中会再创建一个“二哥三妹”的对象，s1 引用的是堆中的对象。

第二行代码，对 s1 执行 intern() 方法，该方法会从字符串常量池中查找“二哥三妹”这个字符串是否存在，此时是存在的，所以 s2 引用的是字符串常量池中的对象。

也就意味着 s1 和 s2 的引用地址是不同的，一个来自堆，一个来自字符串常量池，所以输出的结果为 false。

例 2：

String s1 = new String("二哥") + new String("三妹");
String s2 = s1.intern();
System.out.println(s1 == s2);

第一行代码，会在字符串常量池中创建两个对象，一个是“二哥”，一个是“三妹”，然后在堆中会创建两个匿名对象“二哥”和“三妹”，最后还有一个“二哥三妹”的对象，s1 引用的是堆中“二哥三妹”这个对象。

第二行代码，对 s1 执行 intern() 方法，该方法会从字符串常量池中查找“二哥三妹”这个对象是否存在，此时不存在的，但堆中已经存在了，所以字符串常量池中保存的是堆中这个“二哥三妹”对象的引用，也就是说，s2 和 s1 的引用地址是相同的，所以输出的结果为 true。

例 3：

public static void main(String[] args) {
    String str1 = new StringBuilder("58").append("tongcheng").toString();
    System.out.println(str1);
    System.out.println(str1.intern());
    System.out.println(str1 == str1.intern()); //true

    System.out.println();

    String str2 = new StringBuilder("ja").append("va").toString();
    System.out.println(str2);
    System.out.println(str2.intern());
    System.out.println(str2 == str2.intern()); //false
}

有一个初始化的java字符串(JDK出娘胎自带的)，在加载sun.misc.Version这个类的时候进入常量池。