字符串常量池
作为最基础的数据类型，字符串的分配以和其他对象一样，需要大量的内存。大量频繁的创建字符串会消耗大量的时间和空间，极大的影响程序性能。JVM为了减少内存消耗，做了一下优化。
- 开辟了一个字符串常量池（1.6及之前版本在永久代，1.7之后放到了堆内存）
- 创建字符串常量时首先查，字符串常量池中是否存在，存在返回引用实例，不存在实例化该字符串放到池子中
三种字符串操作（1.7及之后版本）
（1）直接赋值
String s = "Seventeen"; 这种方式创建的字符串只会在字符串常量池中。
- 创建s对象的时候，JVM使用”Seventeen”这个字面量，先去字符串常量池中通过equals(key)方法判断字符串常量池中是否存在。
- 如果存在直接返回引用实例。
- 不存在则会在池子中创建一个新的对象，再返回引用。
（2）new String()
String s1 = new String("Seventeen"); // s1指向内堆存中的对象引用new 对象方式创建字符串，会保证字符串常量池和堆内存中都有这个对象，没有就创建，最后返回堆内存中的对象引用。
- JVM使用”Seventeen”这个字面量，先去字符串常量池中通过equals(key)方法判断字符串常量池中是否存在。
- 如果存在，直接在堆内存中创建个对象，返回堆内存的对象引用。
- 如果不存在，先在字符串常量池中创建对象，然后在堆内存中创建一个对象，最后返回堆内存中的对象引用。
（3）intern方法
public class Test {
public static void main(String[] args) {
String s1 =new String("Seventeen");
String s2 = s1.intern();
System.out.println(s1 == s2);
}
}
intern方法是一个native方法，当时用intern方法时，使用equals方法比较，如果字符串常量池中存在此对象的字符串，则返回池子中的字符串。
否则将当前引用指向堆内存中s1对象的引用。
（jdk1.6之前需要将当前s1复制到字符串常量池）。
字符串常量池位置
- Jdk1.6及之前： 有永久代, 运行时常量池在永久代，运行时常量池包含字符串常量池
- Jdk1.7：有永久代，但已经逐步“去永久代”，字符串常量池从永久代里的运行时常量池分离到堆里
- Jdk1.8及之后： 无永久代，运行时常量池在元空间，字符串常量池里依然在堆里
/**
* 模拟使用大量String常量导致内存溢出
* jdk6：-Xms5M -Xmx5M -XX:PermSize=5M -XX:MaxPermSize=5M
* jdk8：-Xms5M -Xmx5M -XX:MetaspaceSize=5M -XX:MaxMetaspaceSize=5M
*/
public class RuntimeConstantPoolOOM{
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
for (int i = 0; i < 10000000; i++) {
String str = String.valueOf(i).intern();
list.add(str);
}
}
}
运行结果：
jdk8：Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
jdk6：Exception in thread "main" java.lang.OutOfMemoryError: PermGen space
运行结果为：jdk6版本内存溢出在永久代（方法区），jdk8内存溢出在堆内存。
结论：jdk6字符串常量池在永久代，jdk8字符串常量池在堆内存（jdk1.7及已上版本字符串常量池就已经在堆内存了，此处没有1.7的验证，感兴趣的同学可自行验证）。
字符串常量池的设计原理
字符串常量池底层是hotspot的C++实现的，底层类似一个 HashTable， 保存的本质上是字符串对象的引用。
（4）常见的String引用问题：
1.以下代码输出结果和创建了几个对象？
String s1 = new String("he") + new String("llo");
String s2 = s1.intern();
System.out.println(s1 == s2);1.6版本输出结果：
false
，创建
6
个对象1.7及以上版本，输出结果：
true
，创建
5
个对象导致结果不一致原因是：字符串常量池脱离永久代，移入堆中，intern方法也有相应变化。
String s1 =new String("he")+new String("llo");其实是new StringBuild然后使用append方法追加。new对象就会在堆内存中开辟空间。
jdk1.6
执行 String s1 =new String(“he”)+new String(“llo”);
① 将”he”和”llo”在字符串常量池中创建“he”和“llo”
两个对象
，字符串常量池在永久代内存中，所以创建的对象也在永久代内存中。
② 在堆中再创建“he”和“llo”
两个对象
③ 再通过new StringBuilder().append()，在
堆
中
创建一个对象
将字符串“he”和“llo”进行追加拼接
执行String s2 = s1.intern();
① 使用equals方法在字符串常量池中对比查找是否有“hello”
② 如果有返回当前值在池子中的引用，如果没有在
字符串常量池
中
创建一个当前对象，
返回新对象的引用
综上过程：一共创建了
6
个对象，s1通过new StringBuilder创建对象在堆中，s2通过intern创建对象在永久代中，地址值不一样所以s1==s2为
false
。
jdk1.7及以上版本
执行String s1 =new String(“he”)+new String(“llo”);
① 将”he”和”llo”在字符串常量池中创建“he”和“llo”
两个对象
，字符串常量池在堆内存中，所以创建的对象也在堆内存中。
② 在堆中再创建“he”和“llo”
两个对象
③ 再通过new StringBuilder().append()，在
堆
中
创建一个对象
将字符串“he”和“llo”进行追加拼接
执行String s2 = s1.intern();
① 使用equals方法在字符串常量池中对比查找是否有“hello”
② 如果有返回当前值在池子中的引用，如果没有直接指向hello在堆中对象的引用，返回的也是堆中对象的引用
综上过程：一共创建了
5
个对象，s1通过new StringBuilder创建对象在堆中，s2通过intern将常量池中引用指向堆内存中的引用，地址值一样所以s1==s2为
true
。
2.以下代码执行结果是什么？
public class Test {
public static void main(String[] args) {
String s0="Seventeen";
String s1="Seventeen";
String s2="Seven" + "teen";
System.out.println( s0==s1 );
System.out.println( s0==s2 );
}
}
输出结果都为
true
，原因如下：
使用“+”连接的字符串，在编译期就会合并在一起，查看main方法的字节码不难看出。
这三个变量其实都是在进行直接赋值，s0赋值的时候字符串常量池中没有该值，创建一个对象，当s1和s2进行赋值时，字符串常量池中已有该值直接返回该值的引用。所以
三个变量其实指的是同一个内存地址，所以结果都为true。
3.以下程序的执行结果是什么？
public class Test {
public static void main(String[] args) {
String s0="Seventeen";
String s1=new String("Seventeen");
String s2="Seven" + new String("teen");
System.out.println( s0==s1 );// false
System.out.println( s0==s2 );// false
System.out.println( s1==s2 );// false
}
}
执行结果同时为
false
，原因如下：
通过字节码可以看出，s0是直接赋值在编译期就已确定，地址指向的是字符串常量池的引用，s1是new对象是在运行时在堆中创建的对象，s2是new StringBuilder().appen()是一个新的堆中的对象。
三个地址都不一样，所以结果都为false
。
4.以下代码执行结果是什么？
String a = "a1";
String b = "a" + 1;
System.out.println(a == b); // true
String a = "atrue";
String b = "a" + "true";
System.out.println(a == b); // true
String a = "a3.4";
String b = "a" + 3.4;
System.out.println(a == b); // true
执行结果同时为
true
，原因：a都是确认的常量值，b是通过“+”连接的常量值。b在编译期确认常量值，都是直接赋值，所以为
true
。
5.以下代码执行结果是什么？
public class Test {
public static void main(String[] args) {
String s0 = "ab";
String s1 = "b";
String s2 = "a" + s1;
System.out.println(s0 == s2);
}
}
通过字节码能看出，s0和s1是直接赋值，而s2在编译期不能被优化，原因是
由于在字符串的”+”连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的，只能在程序运行期来动态分配即new StringBuilder().append()
，所以上述结果值为false
。
6.以下代码执行结果是什么？
public class Test {
public static void main(String[] args) {
String s0 = "ab";
final String s1 = "b";
String s2 = "a" + s1;
System.out.println(s0 == s2);
}
}
和5中不同的是在s1前面加了final修饰，final修饰的变量，在编译过程中被解析为常量的本地拷贝，也是直接赋值，所以结果为
true。
7.以下代码执行结果是什么？
public class Test {
public static void main(String[] args) {
String s0 = "ab";
final String b = getB();
String s1 = "a" + b;
System.out.println(s0 == s1); // false
}
private static String getB()
{
return "b";
}
}它的值在编译期无法确定，只有在程序运行期调用方法后，将方法的返回值和”s0″来动态连接并分配地址为s1，故上面程序的结果为false。
通过已上例子可以看出
① 直接赋值
String s1 = “a”+”b”+”c”;
等价于
String s1 = “abc”;
② 变量追加赋值
String s0 = “a”;
String s1 = “b”;
String s2 = “c”;
String str = s0+s1+s2;
等价于
StringBuilder temp = new StringBuilder();
temp.append(a).append(b).append(c);
String s = temp.toString();
8.以下代码执行结果是什么？
public class Test {
public static void main(String[] args) {
// StringBuilder对象最终被GC回收，str2最终指向的地址是toString()时new String()的地址
// 没有出现过Seventeen字面量，所以在常量池中没有Seventeen对象，通过append再toString，在堆内存中存在
String str2 = new StringBuilder("Seven").append("teen").toString();
// 执行intern方法时会指向，堆内存中Seventeen对象的引用，所以为 true
System.out.println(str2 == str2.intern()); // true
// 没有出现过java字面量，所以在常量池中没有java对象，通过append再toString，在堆内存中存在
String str1 = new StringBuilder("ja").append("va").toString();
// java作为关键字在JVM初始化的时候，相关类里面早就放到了常量池中，str1使用的是堆中的引用，intern使用的是常量池的引用，所以结果为false
System.out.println(str1 == str1.intern()); // false
// 在常量池中创建Seven对象，并且在堆内存中也会创建一个对象，s1最终指向的是堆内存中的引用
String s1=new String("Seven");
// 常量池中存在Seven对象，调用intern时，指向常量池中Seven对象的引用，所以结果为false
System.out.println(s1==s1.intern()); // false
// 与上面例子同理
String s2=new StringBuilder("teen").toString();
System.out.println(s2==s2.intern()); // false
}
}
基础类型常量池
Byte,Short,Integer,Long,Character,Boolean
这6中基础数据类型的包装类
在堆中
已实现常量池技术，另外两种浮点类型的没有实现。
Byte,Short,Integer,Long,Character
这5种类型包装类也只是实现-128~127之间的常量池。
public class Test {
public static void main(String[] args) {
Short s1 = 127;
Short s2 = 127;
System.out.println("Short类型直接赋值127："+(s1==s2));
Short s3 = 128;
Short s4 = 128;
System.out.println("Short类型直接赋值128："+(s3==s4));
Short s5 = -129;
Short s6 = -129;
System.out.println("Short类型直接赋值-129："+(s5==s6));
Short s7 = new Short((short) 127);
Short s8 = new Short((short) 127);
System.out.println("Short类型new对象："+(s7 == s8));
System.out.println("------------------------------");
Integer i1 = 127;
Integer i2 = 127;
System.out.println("Integer类型直接赋值127："+(i1==i2));
Integer i3 = 128;
Integer i4 = 128;
System.out.println("Integer类型直接赋值128："+(i3==i4));
Integer i5 = -129;
Integer i6 = -129;
System.out.println("Integer类型直接赋值-129："+(i5==i6));
Integer i7 = new Integer(127);
Integer i8 = new Integer(127);
System.out.println("Integer类型new对象："+(i7 == i8));
System.out.println("------------------------------");
Long l1 = 127l;
Long l2 = 127l;
System.out.println("Long类型直接赋值127："+(l1==l2));
Long l3 = 128l;
Long l4 = 128l;
System.out.println("Long类型直接赋值128："+(l3==l4));
Long l5 = -129l;
Long l6 = -129l;
System.out.println("Long类型直接赋值128："+(l5==l6));
Long l7 = new Long(127l);
Long l8 = new Long(127l);
System.out.println("Long类型new对象："+(l7 == l8));
System.out.println("------------------------------");
Character c1 = 127;
Character c2 = 127;
System.out.println("Character类型直接赋值127："+(c1==c2));
Character c3 = 128;
Character c4 = 128;
System.out.println("Character类型直接赋值128："+(c3==c4));
Character c5 = (char) -129;
Character c6 = (char) -129;
System.out.println("Character类型直接赋值128："+(c5==c6));
Character c7 = new Character((char) 127);
Character c8 = new Character((char) 127);
System.out.println("Character类型new对象："+(c7 == c8));
System.out.println("------------------------------");
Boolean b1 = true;
Boolean b2 = true;
System.out.println("Boolean类型直接赋值"+(b1 == b2));
System.out.println("------------------------------");
Double d1 = 1.0;
Double d2 = 1.0;
System.out.println("Boolean类型直接赋值"+(d1 == d2));
}
}
Short类型直接赋值127：true
Short类型直接赋值128：false
Short类型直接赋值-129：false
Short类型new对象：false
------------------------------
Integer类型直接赋值127：true
Integer类型直接赋值128：false
Integer类型直接赋值-129：false
Integer类型new对象：false
------------------------------
Long类型直接赋值127：true
Long类型直接赋值128：false
Long类型直接赋值128：false
Long类型new对象：false
------------------------------
Character类型直接赋值127：true
Character类型直接赋值128：false
Character类型直接赋值128：false
Character类型new对象：false
------------------------------
Boolean类型直接赋值true
------------------------------
Boolean类型直接赋值false