Java - String.intern()方法

一、从字符串比较说起

一个String类型 “==” 比较样例代码如下：

public class StringTest {
        public static void main(String[] args) {
        String str1 = "todo";
        String str2 = "todo";
        String str3 = "to";
        String str4 = "do";
        String str5 = str3 + str4;
        String str6 = new String(str1);
 
        System.out.println("------普通String测试结果------");
        System.out.print("str1 == str2 ? ");
        System.out.println( str1 == str2);
        System.out.print("str1 == str5 ? ");
        System.out.println(str1 == str5);
        System.out.print("str1 == str6 ? ");
        System.out.print(str1 == str6);
        System.out.println();
 
        System.out.println("---------intern测试结果---------");
        System.out.print("str1.intern() == str2.intern() ? ");
        System.out.println(str1.intern() == str2.intern());
        System.out.print("str1.intern() == str5.intern() ? ");
        System.out.println(str1.intern() == str5.intern());
        System.out.print("str1.intern() == str6.intern() ? ");
        System.out.println(str1.intern() == str6.intern());
        System.out.print("str1 == str6.intern() ? ");
        System.out.println(str1 == str6.intern());
        }
}

代码运行结果如下所示：

------普通String测试结果------
str1 == str2 ? true
str1 == str5 ? false
str1 == str6 ? false
---------intern测试结果---------
str1.intern() == str2.intern() ? true
str1.intern() == str5.intern() ? true
str1.intern() == str6.intern() ? true
str1 == str6.intern() ? true

结果分析：
Java 语言会使用常量池保存那些在编译期就已确定的已编译的 .class 文件中的一份数据。主要有类、接口、方法中的常量，以及一些以文本形式出现的符号引用，如类和接口的全限定名、字段的名称和描述符、方法和名称和描述符等。在编译完StringTest 类后，生成的 .class 文件中会在常量池中保存 “todo”、“to” 和 “do” 三个 String 常量。

• 变量 str1 和 str2 均保存的是常量池中 “todo” 的引用，所以 str1==str2 成立；
• 在执行 str5 = str3 + str4这句时，JVM 会先创建一个 StringBuilder 对象，通过 StringBuilder.append() 方法将 str3 与 str4 的值拼接，然后通过 StringBuilder.toString() 返回一个堆中的 String 对象的引用赋值给 str5，因此 str1 和 str5 指向的是不同的 String对象，str1 != str5；
• String str6 = new String(str1) 一句显式创建了一个新的 String 对象，因此 str1 != str6。

二、String.intern() 的原理

String.intern() 是一个 Native 方法，底层调用 C++ 的 StringTable::intern 方法实现。当通过语句 str.intern() 调用 intern() 方法后，JVM 就会在当前类的常量池中查找是否存在与 str 等值的 String：

• 若存在则直接返回常量池中相应 Strnig 的引用；
• 若不存在，则会在常量池中创建一个等值的 String，然后返回这个 String 在常量池中的引用。

因此，只要是等值的String对象，使用intern() 方法返回的都是常量池中同一个 String 引用。所以，这些等值的 String 对象通过 intern() 后使用 == 是可以匹配的。由此就可以理解上面代码中 ------intern------ 部分的结果了：因为 str1、str5 和 str6 是内容相同的 String，所以通过 intern() 方法后他们均成为指向常量池中的同一个 String 的引用变量。因此， str1.intern() == str5.intern() == str6.intern() 均为 true 成立。

三、JDK1.6 中的 String.intern()

JDK1.6中，常量池位于 PermGen（永久代），PermGen 是一块主要用于存放已加载的类信息和字符串池的大小固定的区域。执行 intern() 方法时，若常量池中不存在等值的字符串，JVM 就会在常量池中创建一个等值的字符串，然后返回该字符串的引用。除此以外，JVM 会自动在常量池中保存一份之前已使用过的字符串集合。

Jdk1.6 中使用 intern() 方法的主要问题就在于常量池被保存在 PermGen 中：

• 首先，PermGen 是一块大小固定的区域，一般不同的平台 PermGen 的默认大小也不相同，大致在32M到96M之间。对不受控制的运行时字符串（如用户输入信息等）使用 intern() 方法是不合适的。因为这很有可能会引发 PermGen 内存溢出；
• 其次，String 对象保存在 Java 堆区，Java 堆区与 PermGen 是物理隔离的，因此如果对多个不等值的字符串对象执行 intern 操作，则会导致内存中存在许多重复的字符串，会造成性能损失。

四、JDK1.7 之后的 String.intern()

JDK1.7+ 后，字符串常量池从 PermGen 区移到了堆区。执行 intern 操作时，如果常量池已经存在该字符串，则直接返回字符串引用，否则复制该字符串对象的引用到常量池中并返回。堆区的大小一般不受限，所以将常量池从 PremGen 区移到堆区使得常量池的使用不再受限于固定大小。

除此之外，位于堆区的常量池中的对象可以被GC回收。当常量池中的字符串不再存在指向它的引用时，JVM 就会回收该字符串。可以使用 `-XX:StringTableSize` 虚拟机参数设置字符串池的 map 大小。

字符串常量池内部实现为一个HashMap，当能够确定程序中需要 intern 的字符串数目时，可以将该 map 的 size 设置为所需数目×2 以减少哈希冲突。这样就可以使 String.intern() 每次都只需要常量时间和很小的内存将一个 String 对象存入字符串池中。

五、intern() 方法的适用场景

JDK1.6 中常量池位于 PermGen 区，大小受限，所以不建议适用 intern() 方法，当需要字符串池时，需要自己使用 HashMap 实现。JDK1.7+ 后，常量池由 PermGen 区移到了堆区，还可以通过 `-XX:StringTableSize` 参数设置 StringTable 的大小，常量池的使用不再受限，由此可以重新考虑使用 intern() 方法。

intern() 方法优点：执行速度非常快，内存占用少。直接使用 == 进行地址判断比较要比使用 equals() 方法做值判断快很多；

虽然 intern() 方法具有明显的优势，但若不在恰当的场合中使用，反而会造成性能损失。下面程序对比了使用 intern() 方法和未使用 intern() 方法存储100万个 String 时的性能，从输出结果可以看出，若是单纯使用 intern() 方法进行数据存储的话，程序运行时间要远高于未使用 intern() 方法。

public class InternTest {
    public static void main(String[] args) {
        print("noIntern: " + noIntern());
        print("intern: " + intern());
    }
 
    private static long noIntern(){
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            int j = i % 100;
            String str = String.valueOf(j);
        }
        return System.currentTimeMillis() - start;
    }
 
    private static long intern(){
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            int j = i % 100;
            String str = String.valueOf(j).intern();
        }
        return System.currentTimeMillis() - start;
    }
}

程序运行结果：

noIntern: 53	// 未使用intern方法时，存储100万个String所需时间
intern: 184		// 使用intern方法时，存储100万个String所需时间

分析原因：
由于 intern() 操作每次都需要与常量池中的数据进行比较以查看常量池中是否存在等值数据，同时 JVM 需要确保常量池中的数据的唯一性，这就涉及到加锁机制，这些操作都是占用CPU时间的。所以，如果进行 intern 操作的是大量不会被重复利用的String的话，则有点得不偿失。

由此可见，String.intern() 主要适用于只有有限值，并且这些有限值会被重复利用的场景，如数据库表中的列名、人的姓氏、编码类型等。

六、小结

String.intern() 方法是一种手动将字符串加入常量池中的方法，相关使用技巧总结如下：

1. 如果在常量池中存在与调用 intern() 方法的字符串等值的字符串，就直接返回常量池中相应字符串的引用，否则在常量池中复制一份该字符串，并将其引用返回（JDK1.7+ 会直接在常量池中保存当前字符串的引用）；
2. JDK6 中常量池位于 PremGen 区，大小受限，不建议使用 String.intern() 方法。JDK1.7+ 将常量池移到了 Java 堆区，大小可控，可以重新考虑使用 String.intern() 方法，但是由对比测试可知，使用该方法的耗时不容忽视，所以需要慎重考虑该方法的使用；
3. String.intern() 方法主要适用于程序中需要保存有限个会被反复使用的值的场景，这样可以减少内存消耗，同时在进行比较操作时减少时耗，提高程序性能。

参考资料：
[1] https://blog.csdn.net/u011635492/article/details/81048150
[2] https://blog.csdn.net/guoxiaolongonly/article/details/80425548
[3] https://www.cnblogs.com/wangshen31/p/10404353.html