Java String.intern的深入研究分析

 

String.intern方法在jdk1.7之前和之后的区别:

简单的说其实就一个：在jdk1.7之前，字符串常量存储在方法区的PermGen Space。在jdk1.7之后，字符串常量重新被移到了堆中。

 

Back---重回String设计的初衷：

Java中的String被设计成不可变的，出于以下几点考虑：

1. 字符串常量池的需要。字符串常量池的诞生是为了提升效率和减少内存分配。可以说我们编程有百分之八十的时间在处理字符串，而处理的字符串中有很大概率会出现重复的情况。正因为String的不可变性，常量池很容易被管理和优化。

2. 安全性考虑。正因为使用字符串的场景如此之多，所以设计成不可变可以有效的防止字符串被有意或者无意的篡改。从java源码中String的设计中我们不难发现，该类被final修饰，同时所有的属性都被final修饰，在源码中也未暴露任何成员变量的修改方法。（当然如果我们想，通过反射或者Unsafe直接操作内存的手段也可以实现对所谓不可变String的修改）。

3. 作为HashMap、HashTable等hash型数据key的必要。因为不可变的设计，jvm底层很容易在缓存String对象的时候缓存其hashcode，这样在执行效率上会大大提升。

String类型的常量池比较特殊。它的主要使用方法有两种：

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

 

	    String s = new String("1");  // 同时会生成堆中的对象 以及常量池中1的对象，但是此时s1是指向堆中的对象的
	    s.intern();// 常量池中的已经存在
	    String s2 = "1";
	    System.out.println(s == s2);
	    
	    String s11 = new String("bbb").intern();//直接把对象引用放到常量池，而不是把new的对象赋值给s11 ,所以相等
	    String s22 = "bbb";
	    System.out.println(s11 == s22);   System.out.println(new String("bbb").intern() == s22);
	     
	    String s3 = new String("1") + new String("1");
	    s3.intern();
	    String s4 = "11";
	    System.out.println(s3 == s4);
	   

 String s3 = new String("1") + new String("1");    // 此时生成了四个对象 常量池中的"1" + 2个堆中的"1" + s3指向的堆中的对象（注此时常量池不会生成"11"）
 s3.intern();    // jdk1.7之后，常量池不仅仅可以存储对象，还可以存储对象的引用，会直接将s3的地址存储在常量池
 String s4 = "11";    // jdk1.7之后，常量池中的地址其实就是s3的地址
 System.out.println(s3 == s4); // jdk1.7之前false， jdk1.7之后true
 
 s3 = new String("2") + new String("2");
 s4 = "22";        // 常量池中不存在22，所以会新开辟一个存储22对象的常量池地址
 s3.intern();    // 常量池22的地址和s3的地址不同
 System.out.println(s3 == s4); // false

下面这个作重点分析，地址引用和常量池   地址引用的值相同同样是属于一个常量值

如果先创建常量池对象再比较引用对象就不相等，先把引用值放到常量池才相等针对的就是下面 intern换位置放入常量池

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);
}

打印结果为： true

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);
}

打印结果为： false

第一段代码和第二段代码的改变就是 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 的引用地址是不会相等的。

参考资料如下

https://tech.meituan.com/2014/03/06/in-depth-understanding-string-intern.html