Java String intern()原理及其底层相关

发表于 | 分类于 ， ，
  1. 程序中只有直接写上双引号字符串，才在字符串常量池中
  2. 常量池在1.7之后，放置在了堆空间之中。
  3. String类中对象两种实例化的区别：
    1）直接赋值只会开辟一块堆内存空间，且字符串对象可以保存在对象池中以供下次使用；
    2）采用构造方法会开辟两块堆内存空间，使用intern()方法后可以手工入池。

String s = "Hello world!";这个语句声明的是一个指向对象的引用，名为“s”，可以指向类型为String的任何对象，目前指向”Hello world!”这个String类型的对象，s保存的是”Hello world!”在常量池中的地址。我们并没有声明一个String对象，我们只是声明了一个只能指向String对象的引用变量。
String string = s;我们只是声明了另外一个只能指向String对象的引用，名为string，并没有第二个对象产生，string还是指向原来那个对象，也就是，和s指向同一个对象。

案例1：

1
2
3
4
5
6
7
8
9
10
11
String str = "abc";
String str2 = new String("abc");
System.out.println(str == str2); // false 地址空间的比较
System.out.println(str.equals(str2)); // true
str2 = str2.intern();
System.out.println(str == str2); // true
String str3 = "abc";
System.out.println(str == str3); // true
String str4 = new String(new char[]{'a','b','c'});
System.out.println(str == str4); // false
System.out.println(str4 == str2); // false

分析：

当new String(“abc”)时，在常量池中会创建一个“abc”常量，然后再使用该值对堆中对象初始化。所以不仅是String a = “abc”，直接赋值时会在常量池中产生“abc”字符串。

在这里插入图片描述
当intern()方法被调用的时候，如果在字符串常量池中已经包含了这个String对象，那么就返回该String对象。否则这个String对象就会被添加到常量池中，然后返回该对象的一个引用。并且保证常量池中不会重复。

案例2：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
String s0="java No.1";
String s1="java ";
String s2="No.1";
String s3="java "+"No.1";
String s4=s1+"No.1";
String s5=s1+s2;
System.out.println(s3==s0);
System.out.println(s4==s0);
System.out.println(s5==s0);
System.out.println(s5==s4);
System.out.println("---------");
final String s6="I am ";
final String s7="guYue";
String s8="I am guYue";
String s9=s6+s7;
System.out.println(s8==s9);

结果如下：

true
false
false
false
----------
true

1
2
3
4
String s=new String("a")+new String("b");
s = s.intern();
String s1="ab";
System.out.println(s==s1); //true

我们知道对象s调用intern()方法时，字符串常量池中并没有对象”ab”，所以我们就需要执行将”ab”添加到字符串常量池的的操作。而这时在不同的jdk版本可能就有不同的操作。
①jdk6及之前在常量池中创建一个String对象并返回该对象的引用。
②jdk7及之后在常量池中保存常量池外String对象的引用，并返回该引用。
在这里插入图片描述

总结：
① “?”+”?”
底层直接优化为“??”

1
2
3
4
String s0="java No.1";
String s1="java ";
String s2="No.1";
String s3="java "+"No.1";

查看字节码会发现s0和s3加载过程完全相同。所以是同一个对象。

②“?”+si ，si+”?” , si+sj
我把这三种归为一类因为都有引用类型加入运算。

这时候底层会new一个StringBuilder再调用append方法，最后调用toString方法完成拼接。

1
String s4=s1+"No.1";

查看字节码会发现与上述过程一致。最后再看一下StringBuilder的toString()方法源码，可以发现它返回的是new String，所以肯定不是同一个对象。

1
2
3
4
5
6
//StringBuilder的toString()方法
@Override
public String toString() {
    // Create a copy, don't share the array
    return new String(value, 0, count);
}

③final s1+final s2
这是两个final修饰的String引用的拼接。

1
2
3
4
final String s6="I am ";
final String s7="guYue";
String s8="I am guYue";
String s9=s6+s7;

查看代码的字节码，会发现 最后两行的字节码操作过程是完全相同的，即直接从字符串常量池中取。

案例3：

1
2
3
4
5
6
// 返回的是4个对象
String f = "a" + "b" + "c";
String a1 ="a";
String a2 ="b";
String a3 ="c";
String f1 = a1+a2+a3;

常量池中，不允许有重复字符串。