静态常量池，运行期常量池，字符串常量池
静态常量池
在.Java 文件编译成.class文件的时候，.class文件信息中含有静态常量池，主要是记录编译期生成的各种字面量和符号引用
运行时常量池
加载类的过程中，动态生成的，除了将类的静态常量池加载外，可以动态扩展，将一些符号引用转化位直接引用。将字符串
字面量存在String pool (如果不存在的话)
字符串常量池
逻辑上属于运行时常量池的一部分，在JDK 1.7之前，和运行时常量池一样存放在方法区，在1.7之后，存放在堆空间中xxioang，这样可以更好的垃圾回收，数据结构是一个HashTable 默认是长度60000左右，可以根据项目的需求进行调优
问题
public class Test
{
public static void main(String[] args)
{
String s1 = new String("ab");
String s2 = "ab";
String s3 = "a" + "b";
String s4 = new String("a") + new String("b");
System.out.println("s1==s2的结果:"+(s1 == s2));
System.out.println("s2==s3的结果:"+(s2 == s3));
System.out.println("s2==s4的结果:"+(s2 == s4));
String s5 = new String("cd");
String s6 = s5.intern();
String s7 = "cd";
System.out.println("s5==s7的结果:"+(s5 == s7));
System.out.println("s6==s7的结果:"+(s6 == s7));
String s8 = new String("e") + new String("f");
String s9 = s8.intern();
String s10 = "ef";
System.out.println("s8==s10的结果:"+(s8 == s10));
System.out.println("s9==s10的结果:"+(s9 == s10));
System.out.println("验证常量池");
}
}
结果：
s1==s2的结果:false
s2==s3的结果:true
s2==s4的结果:false
s5==s7的结果:false
s6==s7的结果:true
s8==s10的结果:true
s9==s10的结果:true
验证常量池
分析：
== 对于基本变量比较的是值，对于引用对象比较的是地址
1.s1==s2 的结果:false
--》：String s1 = new String("ab"); 是在堆中创建对象，地址位堆中对象的地址，而
String s2 = "ab"; 先去String常量池中找有没有值位ab的字符串，没有就在堆中创建然后put到
String常量池中查找，所以s1和s2是两个对象，指向不同的地址，所以结果位false
2. s2==s3的结果:true
--》：String s3 = "a" + "b"; 编译class文件的时候会对不变的字面量做优化，直接变成了ab
直接从String常量池中获取，前面s2的对象地址put到String常量池中了，所以地址和s2一样
故结果位true
3.s2==s4的结果:false
--》： String s4 = new String("a") + new String("b"); 其实指令集是利用StringBulider
相加实现的，最后得到s4也是通过new String实现的，所以结果是false(详细解释看下文new String("a")
+ new String("b")的相加原理)
4.s5==s7的结果:false
s6==s7的结果:true
--》： 在这里先说一下s5.intern()方法的作用：查找String常量池中有没有和s5值相等的字符串常量，
如果有就不put,没有就s5的地址put到String常量池中。该方法的返回值时String常量池中保存的String对
象地址
String s5 = new String("cd");
String s6 = s5.intern();
String s7 = "cd";
从这连个语句中可以发现s5先创建了String对象，执行s5.intern()，按照上面说的理论应该时s5==s7应该时
相等的，一开始我也是这么觉得的，执行结果感觉匪夷所思。后来通过验证和查资料得知 String s5 = new String("cd");
会先去String常量池中查找有没有值为cd的值，如果没有就创建了两个对象，一个时自身定义的s5,还有一个put到常量池，
如果有就只创建一个自身对象所以可知s5.intern();常量池中已经有了值为cd的String常量了，所以就不会再put了，
所以s7取的对象时String s5 = new String("cd"); 创建的另外一个对象即put到常量池中的对象，所以s5==s7的结果:false
String s6 = s5.intern();返回的时常量池中的值，所以s6和s7一样,故为true
5:s8==s10的结果:true
s9==s10的结果:true
--》： s9==s10的结果:true没啥好说的，和 s6==s7的结果:true同理
重点是： String s8 = new String("e") + new String("f"); 只创建了一个对象，并不会去判断String
常量池中有没有该值的对象，然后再创建一个，故s8.intern()是put成功的，即常量池中对象地址就是s8的地址，
所以s10==s8为true
验证new String（“xx”）创建对象的个数
我们用idea自带的debug调试工具查看堆中String类型的个数来判断创建对象个数
第一步：我们看到jvm启动的时候就创建了2124个String对象
newString.jpg
第二步：当我们执行new String("ab")的时候显示相对于上一步创建了两个对象
new String1.jpg
第三步：可以看到String s2= "ab" 并没有创建对象，因为New String("ab")创建了两个对象一个put到了String常量池，这样s2就直接去String常量池中的对象,并没有自己创建一个新的put到String常量池
new String2.png
第四步：将 String s1 = new String("ab");和String s2 = "ab";语句调个位置验证，可知在String常量池中没有“ab”值的时候 String s2 = "ab“ 会去创建一个新的对象，然后put到String常量池中
new String 4.jpg
第五步：new String("ab") 创建一个自身对象外，发现String常量池中有值为ab的常量，故不再创建对象，所以这次new String("ab")只创建了一个对象
new String5.jpg
结论：
new String("ab"); 会先去String常量池中查找有没有值为ab的值，如果没有就创建了两个对象，一个时自身定义的,
还有一个put到常量池，如果有就只创建一个自身对象，其实从对象角度来说很好理解，
new String(String x) 这个构造方法传入的必定是个对象，所以new String("ab")的时候ab是先去在堆中构建成对象，然后入参，执行new String(String x) 的构造方法
验证new String(“a”)+new String(“b”)的拼接原理
基于java8：
原理是先创建一个StringBuilder 对象，然后通过append()方法添加，最后返回StringBuilder.toString();
