Java教程:String类的底层原理和版本演变
1 String类的底层演变
JDK8的字符串存储在char类型的数组里面，在java中，一个char类型占两个字节。但是很多时候，一个字符只需要一个字节就可存储，比如各种字母什么的，两个字节存储势必会浪费空间，JDK9的一个优化就在这，内存的优化，所以JDK9之后字符串改成byte类型数组进行存储。
private final byte coder;
在JDK9的String类中，新增了一个属性coder，它是一个编码格式的标识，使用LATIN1还是UTF16，这个是在String生成的时候自动确定的，如果字符串中都是能用LATIN1编码表示，那coder的值就是0，否则就是UTF16编码，coder的值就是1。
可以看到JDK9在这方面的优化，在较多情况下不包含那些奇奇怪怪的字符的时候，足以应付，而这个空间却小了1byte，实现了String空间的压缩。2 String常量池的演变
2.1 StringTable变化
String 的 String Pool是一个固定大小的 Hashtable。
在jdk6中，StringTable的长度固定为1009。
如果放进 String Pool的String非常多，就会造成Hash冲突严重，从而导致链表会很长，而链表长了后直接会造成的影响就是当调用 intern() 时性能会大幅下降。
从jdk7起，StringTable的长度默认值是60013。
使用-XX:StringTableSize可设置StringTable的长度。
在jdk8之前，对StringTableSize的设置没有最小限制。
jdk8开始，StringTable可设置的最小值是1009。
验证：
通过 jps 命令查看进程号
使用 jinfo -flag StringTableSize 进程号 查看StringTable大小 2.2 内存位置变化
Java6及以前，字符串常量池存放在永久代。
Java7开始，字符串常量池的位置调整到Java堆内。
所有的字符串都保存在堆（Heap）中，和其他普通对象一样，这样在进行调优应用时仅需要调整堆大小就可以了。官网说明
https://www.oracle.com/technetwork/java/javase/jdk7-relnotes-418459.html#jdk7changes
JDK6环境下测试：
/*
jdk6中，修改JVM内存大小：
-XX:PermSize=6m -XX:MaxPermSize=6m -Xms6m -Xmx6m
*/
public class StringTableTest {
public static void main(String[] args) {
Set<String> set = new HashSet<String>();
int i=0;
while (true){
set.add(String.valueOf(i++).intern());
}
}
}
执行结果异常信息：
Exception in thread "main" java.lang.OutOfMemoryError: PermGen space
at java.lang.String.intern(Native Method)JDK7环境下测试：
/*
jdk7中，修改JVM内存大小：
-XX:PermSize=6m -XX:MaxPermSize=6m -Xms6m -Xmx6m -XX:-UseGCOverheadLimit
*/
public class StringTableTest {
public static void main(String[] args) {
Set<String> set = new HashSet<String>();
int i=0;
while (true){
set.add(String.valueOf(i++).intern());
}
}
}
执行结果异常信息：
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at java.lang.Integer.toString(Integer.java:331)
at java.lang.String.valueOf(String.java:2954)
at StringTableTest.main(StringTableTest.java:14)3 String的拼接原理
3.1 拼接原理
源代码：
public static void main(String[] args) {
String s1 ="hello";
String s2 ="world";
String s3 = s1+s2;
System.out.println(s3);
}
使用 JDK8 编译后字节码：
0 ldc #2 <hello>
2 astore_1
3 ldc #3 <world>
5 astore_2
6 new #4 <java/lang/StringBuilder>
9 dup
10 invokespecial #5 <java/lang/StringBuilder.<init>>
13 aload_1
14 invokevirtual #6 <java/lang/StringBuilder.append>
17 aload_2
18 invokevirtual #6 <java/lang/StringBuilder.append>
21 invokevirtual #7 <java/lang/StringBuilder.toString>
24 astore_3
25 getstatic #8 <java/lang/System.out>
28 aload_3
29 invokevirtual #9 <java/io/PrintStream.println>
32 return使用 JDK9 编译后字节码：
0 ldc #2 <hello>
2 astore_1
3 ldc #3 <world>
5 astore_2
6 aload_1
7 aload_2
8 invokedynamic #4 <makeConcatWithConstants, BootstrapMethods #0>
13 astore_3
14 getstatic #5 <java/lang/System.out>
17 aload_3
18 invokevirtual #6 <java/io/PrintStream.println>
21 return结论：
JDK8及之前，字符串变量的拼接，底层使用的是StringBuilder对象，利用append方法进行拼接。
（注：jdk1.4之前使用StringBuffer）
JDK9以后的编译器已经改成使用动态指令invokedynamic，
调用StringConcatFactory.makeConcatWithConstants方法进行字符串拼接优化。
3.2 核心方法
makeConcatWithConstants方法在StringConcatFactory类中定义。
makeConcatWithConstants内部调用了doStringConcat，
而doStringConcat方法则调用了generate方法来生成MethodHandle；
generate根据不同的STRATEGY来生成MethodHandle，这些STRATEGY（策略）有
BC_SB（等价于JDK8的优化方式）
BC_SB_SIZED
BC_SB_SIZED_EXACT
MH_SB_SIZED
MH_SB_SIZED_EXACT
MH_INLINE_SIZED_EXACT（默认）
前五种策略本质还是用StringBuilder的实现，而默认的策略MH_INLINE_SIZED_EXACT是直接使用字节数组来操作，并且字节数组长度预先计算好，可以减少字符串复制操作。
可以通过添加JVM参数来改变默认的策略，例如将策略改为BC_SB
-Djava.lang.invoke.stringConcat=BC_SB
-Djava.lang.invoke.stringConcat.debug=true
源码：
==makeConcatWithConstants内部调用了doStringConcat方法==
==doStringConcat方法则调用了generate方法来生成MethodHandle==
==generate根据不同的STRATEGY来生成MethodHandle==
==这些STRATEGY（策略）分别是==
private enum Strategy {
/**
* Bytecode generator, calling into {@link java.lang.StringBuilder}.
*/
BC_SB,
/**
* Bytecode generator, calling into {@link java.lang.StringBuilder};
* but trying to estimate the required storage.
*/
BC_SB_SIZED,
/**
* Bytecode generator, calling into {@link java.lang.StringBuilder};
* but computing the required storage exactly.
*/
BC_SB_SIZED_EXACT,
/**
* MethodHandle-based generator, that in the end calls into {@link java.lang.StringBuilder}.
* This strategy also tries to estimate the required storage.
*/
MH_SB_SIZED,
/**
* MethodHandle-based generator, that in the end calls into {@link java.lang.StringBuilder}.
* This strategy also estimate the required storage exactly.
*/
MH_SB_SIZED_EXACT,
/**
* MethodHandle-based generator, that constructs its own byte[] array from
* the arguments. It computes the required storage exactly.
*/
MH_INLINE_SIZED_EXACT
}==默认的策略MH_INLINE_SIZED_EXACT==
3.3 常见笔试题
/*
产生2个字符串对象：字符串常量池中一个，堆内存中一个。
*/
String s = new String("abc");
/*
产生1个字符串对象：常量池中的"abc"。
代码在编译阶段会优化为 String s = "abc";
*/
String s = "a"+"b"+"c";
/*
5个字符串对象
常量池："a"， "b"
堆内存：new方式的"a"，new方式的"b"，new方式的"ab"
注意：常量池中不会产生"ab"
*/
String s = new String("a") + new String("b");
/*
jdk8及之前创建3个字符串对象：
常量池: "c" , "ab"
堆中: new "abc"
jdk9之后创建2个字符串对象：
常量池： "c"
堆中: new "abc"
*/
String s1 = "c";
String s2 = "a"+"b"+s1;
4 intern()方法的演变
4.1 intern()方法调用区别
public class StringDemo5 {
public static void main(String[] args) {
String s1 = new String("ab");
String s2 = "ab";
System.out.println(s1==s2); //fasle
//intern()方法从常量池中取出"ab"对象
String s1 = new String("ab").intern();
String s2 = "ab";
System.out.println(s1==s2); //true
/*
从常量池中取出和s1内容相同的"ab"对象，此时常量池中没有"ab"对象。
如果常量池中没有该字符串对象：
jdk6及之前，intern()方法会创建新的字符串对象，放入常量池并返回新的地址。
jdk7及之后，intern()方法会将调用者对象的地址放入常量池，并返回调用者对象地址。
*/
String s1 = new String("a") + new String("b");
s1.intern();
String s2 = "ab";
System.out.println(s1==s2); //jdk6 false; jdk7之后true
}
}4.2 intern()方法总结
intern()方法将这个字符串对象尝试放入常量池中，并返回地址。
jdk1.6中：
如果池中有，则不会放入，返回已有的池中的对象的地址。
如果池中没有，则把此对象重新创建一份，放入池中，并返回池中新的对象地址。
jdk1.7起：
如果池中有，则不会放入，返回已有的池中的对象的地址。
如果池中没有，则把此对象的引用地址复制一份，放入池中，并返回池中的引用地址。