深入解析String之intern方法

注:

首先，字符串常量池存储的是编译时确定的字符常量，即直接使用双引号声明出来的String对象，将会在字符串常量池中创建。例如：

首先，字符串常量池存储的是编译时确定的字符常量，即直接使用双引号声明出来的String对象，将会在字符串常量池中创建。例如：

1. JAVA 程序员都做做类似 String s = new String("abc")这个语句创建了几个对象的题目。 这种题目主要就是为了考察程序员对字符串对象的常量池掌握与否。上述的语句中是创建了2个对象，第一个对象是"abc"字符串存储在常量池中，第二个对象在JAVA Heap中的 String 对象。

2. String s3 = new String("1") + new String("1");这个语句在堆中产生了两个匿名对象“1”，和一个s3对象“11”，但是并没有在字符串常量池中产生对象“11”，因为它不是运行时常量，在编译时期没有确定下来。

3. String a="a"+"a";与String a="aa";是一致的。而String b="a";String c="a"; a=b+c;是不一样的，其实运行时是这样的String a=new StringBuilder().append(b).append(c).toString().

4. jdk1.6以下的intern();在JDK1.6中它做了个小动作：检查字符串池里是否存在该字符串，如果存在，就返回池里的字符串；如果不存在，该方法会把该字符串添加到字符串池中，然后再返回它的引用。

jdk1.7以上的intern();常量池已经移到堆中了，s.intern();如果已经存在s字符串，则返回该引用；如果不存在，则将s的引用存到常量池中，没有必要在常量池中新建一个对象了。

0 引言

    在 JAVA 语言中有8中基本类型和一种比较特殊的类型String。这些类型为了使他们在运行过程中速度更快，更节省内存，都提供了一种常量池的概念。常量池就类似一个JAVA系统级别提供的缓存。

    8种基本类型的常量池都是系统协调的，String类型的常量池比较特殊。它的主要使用方法有两种：

        * 直接使用双引号声明出来的String对象会直接存储在常量池中。

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

 

1，jdk6 和 jdk7 下 intern 的区别

    相信很多 JAVA 程序员都做做类似 String s = new String("abc")这个语句创建了几个对象的题目。 这种题目主要就是为了考察程序员对字符串对象的常量池掌握与否。上述的语句中是创建了2个对象，第一个对象是"abc"字符串存储在常量池中，第二个对象在JAVA Heap中的 String 对象。

来看一段代码：

public static void main(String[] args) {

    String s = new String("1");

    s.intern();

    String s2 = "1";

    System.out.println(s == s2);

 

    String s3 = new String("1") + new String("1");

    s3.intern();

    String s4 = "11";

    System.out.println(s3 == s4);

}

打印结果是

* jdk6 下false false

* jdk7 下false true

具体为什么稍后再解释，然后将s3.intern();语句下调一行，放到String s4 = "11";后面。将s.intern(); 放到String s2 = "1";后面。是什么结果呢

public static void main(String[] args) {

    String s = new String("1");

    String s2 = "1";

    s.intern();

    System.out.println(s == s2);

 

    String s3 = new String("1") + new String("1");

    String s4 = "11";

    s3.intern();

    System.out.println(s3 == s4);

}

打印结果为：

* jdk6 下false false

* jdk7 下false false

 

####1，jdk6中的解释 

注：图中绿色线条代表 string 对象的内容指向。 黑色线条代表地址指向。

如上图所示。首先说一下 jdk6中的情况，在 jdk6中上述的所有打印都是 false 的，因为 jdk6中的常量池是放在 Perm 区中的，Perm 区和正常的 JAVA Heap 区域是完全分开的。上面说过如果是使用引号声明的字符串都是会直接在字符串常量池中生成，而 new 出来的 String 对象是放在 JAVA Heap 区域。所以拿一个 JAVA Heap 区域的对象地址和字符串常量池的对象地址进行比较肯定是不相同的，即使调用String.intern方法也是没有任何关系的。

 

####2，jdk7中的解释

再说说 jdk7 中的情况。这里要明确一点的是，在 Jdk6 以及以前的版本中，字符串的常量池是放在堆的 Perm 区的，Perm 区是一个类静态的区域，主要存储一些加载类的信息，常量池，方法片段等内容，默认大小只有4m，一旦常量池中大量使用 intern 是会直接产生java.lang.OutOfMemoryError: PermGen space错误的。 所以在 jdk7 的版本中，字符串常量池已经从 Perm 区移到正常的 Java Heap 区域了。为什么要移动，Perm 区域太小是一个主要原因，当然据消息称 jdk8 已经直接取消了 Perm 区域，而新建立了一个元区域。应该是 jdk 开发者认为 Perm 区域已经不适合现在 JAVA 的发展了。

正式因为字符串常量池移动到 JAVA Heap 区域后，再来解释为什么会有上述的打印结果。

* 在第一段代码中，先看 s3和s4字符串。String s3 = new String("1") + new String("1");，这句代码中现在生成了2最终个对象，是字符串常量池中的“1” 和 JAVA Heap 中的 s3引用指向的对象。中间还有2个匿名的new String("1")我们不去讨论它们。此时s3引用对象内容是"11"，但此时常量池中是没有 “11”对象的。

* 接下来s3.intern();这一句代码，是将 s3中的“11”字符串放入 String 常量池中，因为此时常量池中不存在“11”字符串，因此常规做法是跟 jdk6 图中表示的那样，在常量池中生成一个 "11" 的对象，关键点是 jdk7 中常量池不在 Perm 区域了，这块做了调整。常量池中不需要再存储一份对象了，可以直接存储堆中的引用。这份引用指向 s3 引用的对象。 也就是说引用地址是相同的。

* 最后String s4 = "11"; 这句代码中"11"是显示声明的，因此会直接去常量池中创建，创建的时候发现已经有这个对象了，此时也就是指向 s3 引用对象的一个引用。所以 s4 引用就指向和 s3 一样了。因此最后的比较 s3 == s4 是 true。

* 再看 s 和 s2 对象。 String s = new String("1"); 第一句代码，生成了2个对象。常量池中的“1” 和 JAVA Heap 中的字符串对象。s.intern(); 这一句是 s 对象去常量池中寻找后发现 “1” 已经在常量池里了。

* 接下来String s2 = "1"; 这句代码是生成一个 s2的引用指向常量池中的“1”对象。 结果就是 s 和 s2 的引用地址明显不同。图中画的很清晰。

* 来看第二段代码，从上边第二幅图中观察。第一段代码和第二段代码的改变就是 s3.intern(); 的顺序是放在String s4 = "11";后了。这样，首先执行String s4 = "11";声明 s4 的时候常量池中是不存在“11”对象的，执行完毕后，“11“对象是 s4 声明产生的新对象。然后再执行s3.intern();时，常量池中“11”对象已经存在了，因此 s3 和 s4 的引用是不同的。

* 第二段代码中的 s 和 s2 代码中，s.intern();，这一句往后放也不会有什么影响了，因为对象池中在执行第一句代码String s = new String("1");的时候已经生成“1”对象了。下边的s2声明都是直接从常量池中取地址引用的。 s 和 s2 的引用地址是不会相等的。

####小结

从上述的例子代码可以看出 jdk7 版本对 intern 操作和常量池都做了一定的修改。主要包括2点：

* 将String常量池 从 Perm 区移动到了 Java Heap区

* String#intern 方法时，如果存在堆中的对象，会直接保存对象的引用，而不会重新创建对象。

参考资料：

方式一：String a = “aaa” ;

方式二：String b = new String(“aaa”);

两种方式都能创建字符串对象，但方式一要比方式二更优。

因为字符串是保存在常量池中的，而通过new创建的对象会存放在堆内存中。

一：常量池中已经有字符串常量”aaa”

通过方式一创建对象，程序运行时会在常量池中查找”aaa”字符串，将找到的”aaa”字符串的地址赋给a。

通过方式二创建对象，无论常量池中有没有”aaa”字符串，程序都会在堆内存中开辟一片新空间存放新对象。

一：常量池中没有字符串常量”aaa”

通过方式一创建对象，程序运行时会将”aaa”字符串放进常量池，再将其地址赋给a。

通过方式二创建对象，程序会在堆内存中开辟一片新空间存放新对象，同时会将”aaa”字符串放入常量池，相当于创建了两个对象。

测试：

public class StringNewTest {

public static void main(String[] args) {

String a = "aaa";

String b = "aaa";

String c = new String("aaa");

System.out.println("a==b:"+(a == b));

System.out.println("a==c:"+(a == c));

System.out.println("a与b的值相等:"+(a.equals(c)));

}

}

结果： 

a==b:true 

a==c:false 

a与b的值相等:true

常见试题解答

有了对以上的知识的了解，我们现在再来看常见的面试或笔试题就很简单了： 

Q：下列程序的输出结果： 

String s1 = “abc”; 

String s2 = “abc”; 

System.out.println(s1 == s2); 

A：true，均指向常量池中对象。

Q：下列程序的输出结果： 

String s1 = new String(“abc”); 

String s2 = new String(“abc”); 

System.out.println(s1 == s2); 

A：false，两个引用指向堆中的不同对象。

Q：下列程序的输出结果： 

String s1 = “abc”; 

String s2 = “a”; 

String s3 = “bc”; 

String s4 = s2 + s3; 

System.out.println(s1 == s4); 

A：false，因为s2+s3实际上是使用StringBuilder.append来完成，会生成不同的对象。

Q：下列程序的输出结果： 

String s1 = “abc”; 

final String s2 = “a”; 

final String s3 = “bc”; 

String s4 = s2 + s3; 

System.out.println(s1 == s4); 

A：true，因为final变量在编译后会直接替换成对应的值，所以实际上等于s4=”a”+”bc”，而这种情况下，编译器会直接合并为s4=”abc”，所以最终s1==s4。

Q：下列程序的输出结果： 

String s = new String(“abc”); 

String s1 = “abc”; 

String s2 = new String(“abc”); 

System.out.println(s == s1.intern()); 

System.out.println(s == s2.intern()); 

System.out.println(s1 == s2.intern()); 

A：false，false，true。

参考资料：https://tech.meituan.com/in_depth_understanding_string_intern.html