字符串常量池（StringTable）总结

一、String的基本特性

二、String的不可变性

三、String的内存分配

四、String的基本操作

五、intern()的使用

六、常见面试题

一、String的基本特性

String：字符串，使用一对""引起来表示。
- String s1 = "mogublog" ; // 字面量的定义方式
- String s2 = new String("abc");

String声明为final的，不可被继承；
String实现了Serializable接口：表示字符串是支持序列化的。实现了Comparable接口：表示String可以比较大小；
String在jdk8及以前内部定义了final char[] value用于存储字符串数据。JDK9时改为byte[]；

为什么JDK9改变了结构？

String类的当前实现将字符存储在char数组中，每个字符使用两个字节(16位)。从许多不同的应用程序收集的数据表明，字符串是堆使用的主要组成部分，而且，大多数字符串对象只包含拉丁字符，这些字符只需要一个字节的存储空间，因此这些字符串对象的内部char数组中有一半的空间将不会使用。

我们建议改变字符串的内部表示class从utf - 16字符数组到【字节数组 + 一个encoding-flag字段】。新的String类将根据字符串的内容存储编码为ISO-8859-1/Latin-1(每个字符一个字节)或UTF-16(每个字符两个字节)的字符。编码标志将指示使用哪种编码。

结论：String再也不用char[] 来存储了，改成了byte [] 加上编码标记，节约了一些空间。

// 之前
private final char value[];
// 之后
private final byte[] value

同时基于String的数据结构，例如StringBuffer和StringBuilder也同样做了修改。

二、String的不可变性

String：代表不可变的字符序列。简称：不可变性。

当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。

下面通过代码演示String的不可变性：

public class StringTest01 {private static void test1() {// 字面量定义的方式，“abc”存储在字符串常量池中String s1 = "abc";String s2 = "abc";System.out.println(s1 == s2);  //trues1 = "hello";System.out.println(s1 == s2);  //falseSystem.out.println(s1);        //helloSystem.out.println(s2);        //abcSystem.out.println("----------------");}private static void test2() {String s1 = "abc";String s2 = "abc";// 只要进行了修改，就会重新创建一个对象，这就是不可变性s2 += "def";System.out.println(s1);        //abcSystem.out.println(s2);        //abcdefSystem.out.println("----------------");}private static void test3() {String s1 = "abc";String s2 = s1.replace('a', 'm');System.out.println(s1);       //abcSystem.out.println(s2);       //mbc}public static void main(String[] args) {test1();test2();test3();}}

运行结果：

true
false
hello
abc
----------------
abc
abcdef
----------------
abc
mbc

通过上面的示例，我们应该了解了String的不可变性，下面我们再通过一道常见的面试题来加强对String不可变性的理解。

public class StringTest02 {String str = new String("good");char[] ch = {'t', 'e', 's', 't'};public void change(String str, char ch[]) {str = "test ok";ch[0] = 'b';}public static void main(String[] args) {StringTest02 stringTest02 = new StringTest02();stringTest02.change(stringTest02.str, stringTest02.ch);System.out.println(stringTest02.str); //goodSystem.out.println(stringTest02.ch);  //best}
}

运行结果：

good
best

我们需要注意，字符串常量池是不会存储相同内容的字符串的。

String的string Pool是一个固定大小的Hashtable，默认值大小长度是1009。如果放进string Pool的string非常多，就会造成Hash冲突严重，从而导致链表会很长，而链表长了后直接会造成的影响就是当调用string.intern时性能会大幅下降。

我们可以使用-XX:StringTablesize可设置stringTable的长度。

在jdk6中stringTable是固定的，就是1009的长度，所以如果常量池中的字符串过多就会导致效率下降很快。

在jdk7中，stringTable的长度默认值是60013，在JDK8中，StringTable可以设置的最小值为1009。

三、String的内存分配

在Java语言中有8种基本数据类型和一种比较特殊的类型string。这些类型为了使它们在运行过程中速度更快、更节省内存，都提供了一种常量池的概念。

常量池就类似一个Java系统级别提供的缓存。8种基本数据类型的常量池都是系统协调的，string类型的常量池比较特殊。它的主要使用方法有两种：

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

比如：String info= "abcd"；

(二)、如果不是用双引号声明的String对象，可以使用String提供的intern()方法。

Java 6及以前，字符串常量池存放在永久代；
Java 7将字符串常量池的位置调整到Java堆内，所有的字符串都保存在堆（Heap）中，和其他普通对象一样，这样可以让你在进行调优应用时仅需要调整堆大小就可以了。
Java8元空间，字符串常量还是在堆空间；

为什么StringTable从永久代调整到堆中？

在JDK 7中，interned字符串不再在Java堆的永久代中分配，而是在Java堆的主要部分(称为年轻代和年老代)中分配，与应用程序创建的其他对象一起分配。此更改将导致驻留在主Java堆中的数据更多，驻留在永久生成中的数据更少，因此可能需要调整堆大小。由于这一变化，大多数应用程序在堆使用方面只会看到相对较小的差异，但加载许多类或大量使用字符串的较大应用程序会出现这种差异。主要是下面两个原因：

永久代的空间默认比较小，而且使用参数不好动态设置其大小；
永久代的垃圾回收频率低，导致大量不使用的string字符串常量无法回收；

四、String的基本操作

Java语言规范里要求完全相同的字符串字面量，应该包含同样的Unicode字符序列（包含同一份码点序列的常量），并且必须是指向同一个String类实例。

(一)、字符串拼接操作

常量与常量的拼接结果在常量池，原理是编译期优化；
常量池中不会存在相同内容的变量；
只要其中有一个是变量，结果就在堆中，变量拼接的原理是StringBuilder；
如果拼接的结果调用intern()方法，则主动将常量池中还没有的字符串对象放入池中，并返回此对象地址；

来看一个字符串拼接的例子：

public class StringTest03 {private static void test1() {String s1 = "a" + "b" + "c";  // 得到 abc的常量池String s2 = "abc"; // abc存放在常量池，直接将常量池的地址返回/*** 最终java编译成.class，再执行.class*/System.out.println(s1 == s2);       // true，因为存放在字符串常量池System.out.println(s1.equals(s2));  // true}private static void test2() {String s1 = "javaEE";String s2 = "hadoop";String s3 = "javaEEhadoop";String s4 = "javaEE" + "hadoop";String s5 = s1 + "hadoop";String s6 = "javaEE" + s2;String s7 = s1 + s2;System.out.println(s3 == s4); // trueSystem.out.println(s3 == s5); // falseSystem.out.println(s3 == s6); // falseSystem.out.println(s3 == s7); // falseSystem.out.println(s5 == s6); // falseSystem.out.println(s5 == s7); // falseSystem.out.println(s6 == s7); // falseString s8 = s6.intern();System.out.println(s3 == s8); // true  由于s6拼接之后的javaEEhadoop已经在常量池中，intern将会直接返回javaEEhadoop的地址给s8}public static void main(String[] args) {test1();test2();}
}

从上述的结果我们可以知道：

如果拼接符号的前后出现了变量，则相当于在堆空间中new String()，具体的内容为拼接的结果；而调用intern方法，则会判断字符串常量池中是否存在JavaEEhadoop值，如果存在则返回常量池中的值，否则就在常量池中创建。

(二)、底层原理

拼接操作的底层其实使用了StringBuilder：

我们一起来看一下上述程序编译后的字节码文件：

上述程序中s1 + s2的执行细节大概如下：

StringBuilder s = new StringBuilder();
s.append(s1);
s.append(s2);
s.toString(); -> 类似于new String("ab");

在JDK5之后，使用的是StringBuilder，在JDK5之前使用的是StringBuffer。

String	StringBuffer	StringBuilder
String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，不仅效率低下，而且浪费大量优先的内存空间	StringBuffer是可变类，和线程安全的字符串操作类，任何对它指向的字符串的操作都不会产生新的对象。每个StringBuffer对象都有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，会自动增加容量	可变类，速度更快
不可变	可变	可变
	线程安全	线程不安全
	多线程操作字符串	单线程操作字符串

注意，我们左右两边如果是变量的话，就是需要new StringBuilder进行拼接，但是如果使用的是final修饰，则是从常量池中获取。所以说拼接符号左右两边都是字符串常量或常量引用，则仍然使用编译器优化。也就是说被final修饰的变量，将会变成常量，类和方法将不能被继承。

在开发中，能够使用final的时候，建议使用上。

public class StringTest04 {public static void test4() {final String s1 = "a";final String s2 = "b";String s3 = "ab";String s4 = s1 + s2;System.out.println(s3 == s4);  //true}public static void main(String[] args) {test4();}
}

运行结果：

true

为什么是true呢？我们查看其字节码：

可以看到，如果是字符串常量的引用的话，在编译的时候就已经拼接好了，还是使用的编译器优化，所以返回true。

(三)、拼接操作和append性能对比

public class StringTest05 {public static void method1(int highLevel) {long startTime = System.currentTimeMillis();String src = "";for (int i = 0; i < highLevel; i++) {src += "a"; // 每次循环都会创建一个StringBuilder对象}System.out.println("拼接操作耗时：" + (System.currentTimeMillis() - startTime));}public static void method2(int highLevel) {long startTime = System.currentTimeMillis();StringBuilder sb = new StringBuilder();for (int i = 0; i < highLevel; i++) {sb.append("a");}System.out.println("append拼接操作耗时：" + (System.currentTimeMillis() - startTime));}public static void main(String[] args) {method1(100000);System.out.println("============");method2(100000);}
}

运行结果：

拼接操作耗时：7656
============
append拼接操作耗时：8

可见，方法1耗费的时间：7656ms，方法2消耗时间：8ms。

结论：

通过StringBuilder的append()方式添加字符串的效率，要远远高于String的字符串拼接方法。

好处：

StringBuilder的append的方式，自始至终只创建一个StringBuilder的对象；
对于字符串拼接的方式，还需要创建很多StringBuilder对象和调用toString时候创建的String对象；
内存中由于创建了较多的StringBuilder和String对象，内存占用过大，如果进行GC那么将会耗费更多的时间；

改进的空间：

我们使用的是StringBuilder的空参构造器，默认的字符串容量是16，然后将原来的字符串拷贝到新的字符串中，我们也可以默认初始化更大的长度，减少扩容的次数；
因此在实际开发中，我们能够确定，前前后后需要添加的字符串不高于某个限定值，那么建议使用构造器创建一个阈值的长度；

五、intern()的使用

intern()是一个native方法，调用的是底层C的方法。

在调用intern方法时，如果常量池中已经包含了由equals(object)方法确定的与该字符串对象相等的字符串，则返回池中的字符串。否则，该字符串对象将被添加到池中，并返回对该字符串对象的引用。

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

String myInfo = new string("abc").intern();

也就是说，如果在任意字符串上调用string.intern方法，那么其返回结果所指向的那个类实例，必须和直接以常量形式出现的字符串实例完全相同。因此，下列表达式的值必定是true：

（"a"+"b"+"c"）.intern（）== "abc" =======> true

通俗点讲，Interned string就是确保字符串在内存里只有一份拷贝，这样可以节约内存空间，加快字符串操作任务的执行速度。注意，这个值会被存放在字符串内部池（String Intern Pool）。

结论：对于程序中大量使用存在的字符串时，尤其存在很多已经重复的字符串时，使用intern()方法能够节省内存空间。

六、常见面试题

(一)、new String("ab")会创建几个对象

public class StringTest06 {public static void main(String[] args) {String str = new String("ab");}
}

我们查看上述程序的字节码：

0 new #2 <java/lang/String>    //第一个对象：new关键字在堆空间中创建；3 dup4 ldc #3 <ab>                 //第二个对象：字符串常量池中的对象；6 invokespecial #4 <java/lang/String.<init>>      9 astore_1
10 return

可以看到，由字节码可知创建了2个对象。

一个对象是：new关键字在堆空间中创建；
另一个对象：字符串常量池中的对象；

(二)、new String("a") + new String("b") 会创建几个对象

public class StringTest07 {public static void main(String[] args) {String str = new String("a") + new String("b");}
}

我们查看上述程序的字节码：

0 new #2 <java/lang/StringBuilder>        //第一个对象：new StringBuilder()3 dup4 invokespecial #3 <java/lang/StringBuilder.<init>>7 new #4 <java/lang/String>      //第二个对象：new String("a")
10 dup
11 ldc #5 <a>     //第三个对象：常量池的"a"
13 invokespecial #6 <java/lang/String.<init>>
16 invokevirtual #7 <java/lang/StringBuilder.append>
19 new #4 <java/lang/String>     //第四个对象：new String("b")
22 dup
23 ldc #8 <b>        //第五个对象：常量池的 "b"
25 invokespecial #6 <java/lang/String.<init>>
28 invokevirtual #7 <java/lang/StringBuilder.append>
31 invokevirtual #9 <java/lang/StringBuilder.toString>
34 astore_1
35 return

由字节码可知，一共创建了5个对象：

对象1：new StringBuilder()
对象2：new String("a")
对象3：常量池"a"
对象4：new String("b")
对象5：常量池的 "b"

但是如果更严谨一点来说，应该是6个对象，原因是StringBuilder.toString()方法内部是通过new String()也创建了一个对象。

//java.lang.StringBuilder#toString
public String toString() {return new String(value, 0, count);
}

一共创建了6个对象：

对象1：new StringBuilder()
对象2：new String("a")
对象3：常量池的 a
对象4：new String("b")
对象5：常量池的 b
对象6：toString中会创建一个 new String("ab")
- 调用toString方法，不会在常量池中生成"ab"常量。

(三)、面试题拓展

来看下面一段程序，下面的程序在不同的JDK版本中，运行结果有点区别。

首先我们来看下在JDK6中：

String s = new String("1");  // 在常量池中已经有了
s.intern(); // 将该对象放入到常量池。但是调用此方法没有太多的区别，因为已经存在了1
String s2 = "1";
System.out.println(s == s2); //jdk6: falseString s3 = new String("1") + new String("1");
s3.intern();
String s4 = "11";
System.out.println(s3 == s4); //jdk6: false

解释：

a、s的地址指向的是堆空间中new String("1")对象的地址，而s2的地址指向的是常量池中"1"的地址，很显然，两个的地址不同，所以s == s2返回false。

b、s3的地址指向的是堆空间new String("11")对象的地址，执行完【new String("1") + new String("1")】之后，字符串常量池不会存在"11"字符串。然后调用s3.intern();这时候将会在常量池中保存"11"常量，s4指向的地址是前面intern方法放在常量池中"11"的地址，很显然，s3的地址和s4的地址不同，所以s3 == s4返回false。

然后我们再看下在JDK7/8中的运行结果：

String s = new String("1");  // 在常量池中已经有了
s.intern(); // 将该对象放入到常量池。但是调用此方法没有太多的区别，因为已经存在了1
String s2 = "1";
System.out.println(s == s2); //jdk6: false     jdk7/8：falseString s3 = new String("1") + new String("1");
//jdk6中，intern方法就创建了一个新的"11"常量，也就有新的地址；
//jdk7/8中，intern方法会先检查堆空间中是否已经创建了"11"字符串，而刚好上一行代码就创建了
//"11"字符串，所以这时候常量池中的对象，它的地址其实记录的是堆空间中创建的"11"的地址。
s3.intern();
String s4 = "11";
System.out.println(s3 == s4); //jdk6: false     jdk7/8：true

解释：

a、同jdk6，s的地址指向的是堆空间中new String("1")对象的地址，而s2的地址指向的是常量池中"1"的地址，很显然，两个的地址不同，所以s == s2返回false。

b、s3的地址指向的是堆空间new String("11")对象的地址，执行完【new String("1") + new String("1")】之后，字符串常量池不会存在"11"字符串。然后调用s3.intern();注意了，在jdk7/8以后，字符串常量池放在堆空间了，intern方法会先检查堆空间中是否已经创建了"11"字符串，而刚好前面一行代码【new String("1") + new String("1")】就创建了"11"字符串，所以这时候常量池中的对象，它的地址其实记录的是堆空间中创建的"11"的地址，s4指向的地址是常量池中"11"的地址，很显然，s3的地址和s4的地址相同，所以s3 == s4返回true。

简单画了个图，帮助理解一下：

理解了上面的那个例子，我们再来看一下下面的例子：

public class StringTest09 {public static void main(String[] args) {String s3 = new String("1") + new String("1");String s4 = "11";  // 在常量池中生成的字符串s3.intern();  // 然后s3就会从常量池中找，发现有了，就什么事情都不做System.out.println(s3 == s4);  //false}
}

解释：

a、String s3 = new String("1") + new String("1");执行完后常量池中不会存在"11"字符串常量，然后执行String s4 = "11"，这时候在常量池中生成"11"字符串，然后执行s3.intern()，然后s3就会从常量池中找，发现有了，就什么事情都不做。即s3执行的是堆空间中new出来的对象的地址，s4指向的是常量池"11"的地址，两者地址不同，所以s3 == s4，返回false。

简单做个总结：String的intern()的使用：

JDK1.6中，将这个字符串对象尝试放入常量池中：

如果常量池中有，则并不会放入。返回已有的常量池中的对象的地址；
如果没有，会把此对象复制一份，放入常量池中，并返回常量池中的对象地址；

JDK1.7起，将这个字符串对象尝试放入常量池中：

如果常量池中有，则并不会放入。返回已有的常量池中的对象的地址；
如果没有，则会把对象的引用地址复制一份，放入常量池中，并返回常量池中的引用地址；