静态常量池，运行期常量池，字符串常量池

静态常量池

在.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();