知识归纳笔记（一）：考查常量池、堆、栈

常量池、堆、栈

.一、首先我们先看一到基础题，代码如下

 public static void main(String[] args)  {
        
        String s1 = "Hello";
        String s2 = "Hello";
        String s3 = "Hel" + "lo";
        String s4 = "Hel" + new String("lo");
        String s5 = new String("Hello");
        String s6 = s5.intern();
        String s7 = "H";
        String s8 = "ello";
        String s9 = s7 + s8;
                  
        System.out.println(s1 == s2);  // true
        System.out.println(s1 == s3);  // true
        System.out.println(s1 == s4);  // false
        System.out.println(s4 == s5);  // false
        System.out.println(s1 == s9);  // false
        System.out.println(s1 == s6);  // true
    }

该题考查的知识点为常量池、堆、栈

答题准备：知识点复习

• 常量池
  • 静态常量池：即*.class文件中的常量池，class文件中的常量池不仅仅包含字符串(数字)字面量，还包含类、方法的信息，占用class文件绝大部分空间。主要用于存放两大类常量
    • 字面量(Literal)：字面量相当于Java语言层面常量的概念，如文本字符串，声明为final的常量值等
    • 符号引用量(Symbolic References)：编译原理方面的概念，包括了类和接口的全限定名、字段名称和描述符以及方法名称和描述符三种类型的常量
  • 运行时常量池：jvm虚拟机在完成类装载操作后，将class文件中的常量池载入到内存中，并保存在方法区中，我们常说的常量池，就是指方法区中的运行时常量池。
    • 运行时常量池中的常量，基本来源于各个class文件中的常量池。（我认为是静态常量池加载到内存后变成了另一种说法—>运行时常量池）
    • 程序运行时，除非手动向常量池中添加常量(比如调用intern方法)，否则jvm不会自动添加常量到常量池。
• 堆、栈：点击进入

有一句话说的好，要想更好的理解常量池，必须要关注编译期的行为（编译期间就将一部分数据存放于该区域），所以下我将题目反编译一下，代码如下：

  public static void main(String[] args)
  {
    String s1 = "Hello";
    String s2 = "Hello";
    String s3 = "Hello";
    String s4 = "Hel" + new String("lo");
    String s5 = new String("Hello");
    String s6 = s5.intern();
    String s7 = "H";
    String s8 = "ello";
    String s9 = s7 + s8;

    System.out.println(s1 == s2);
    System.out.println(s1 == s3);
    System.out.println(s1 == s4);
    System.out.println(s4 == s5);
    System.out.println(s1 == s9);
    System.out.println(s1 == s6);
  }

解题前言：首先说明一点，在java 中，直接使用==操作符，比较的是两个字符串的引用地址，并不是比较内容，比较内容请用String.equals()。

（1）.s1 == s2这个非常好理解，s1、s2在赋值时，均使用的字符串字面量，说白话点，就是直接把字符串写死，在编译期间，这种字面量会直接放入class文件的常量池中，从而实现复用，载入运行时常量池后，s1、s2指向的是同一个内存地址，所以相等。

（2）.s1 == s3这个地方有个坑，s3虽然是动态拼接出来的字符串，但是所有参与拼接的部分都是已知的字面量，在编译期间，这种拼接会被优化，编译器直接帮你拼好，因此String s3 = "Hel" + "lo";在class文件中被优化成String s3 = "Hello"（反编译代码显示），所以s1 == s3成立。只有使用引号包含文本的方式创建的String对象之间使用“+”连接产生的新对象才会被加入字符串池中。

（3）. s1 == s4当然不相等，s4虽然也是拼接出来的，但new String("lo")这部分不是已知字面量，是一个不可预料的部分，编译器不会优化，必须等到运行时才可以确定结果，结合字符串不变定理，鬼知道s4被分配到哪去了，所以地址肯定不同。对于所有包含new方式新建对象（包括null）的“+”连接表达式，它所产生的新对象都不会被加入字符串池中。

（4）.s4 == s5已经不用解释了，绝对不相等，二者都在堆中，但地址不同。

（5）.s1 == s9也不相等，道理差不多，虽然s7、s8在赋值的时候使用的字符串字面量，但是拼接成s9的时候，s7、s8作为两个变量，都是不可预料的，编译器毕竟是编译器，不可能当解释器用，不能在编译期被确定，所以不做优化，只能等到运行时，在堆中创建s7、s8拼接成的新字符串，在堆中地址不确定，不可能与方法区常量池中的s1地址相同。

（6）.s1 == s6这两个相等完全归功于intern方法，s5在堆中，内容为Hello ，intern方法会尝试将Hello字符串添加到常量池中，并返回其在常量池中的地址，因为常量池中已经有了Hello字符串，所以intern方法直接返回地址；而s1在编译期就已经指向常量池了，因此s1和s6指向同一地址，相等。

知识点疑问

    public static void main(String[] args)  {
        
          String  a0=new String("Hello-a0");
          System.out.println("步骤一："+(a0 == a0.intern()));//false
        
          String a1 = new StringBuffer("Hello-a1").toString();
          System.out.println("步骤二："+(a1 == a1.intern())); //false
        
          String a2 = new StringBuffer("Hello-").append("a2").toString();
          System.out.println("步骤三："+(a2 == a2.intern()));  //true
           
          String a3 = "Hello-a3";
          String s3 = new StringBuffer("Hello-").append("a3").toString();
          System.out.println("步骤四："+(s3 == s3.intern()));  //false
           
          String a4 = new StringBuffer("Hello-").append("a4").toString();
          a4.intern();
          System.out.println("步骤五："+(a4 == a4.intern())); //true 
           }

 输出结果如下：

步骤一：false
步骤二：false
步骤三：true
步骤四：false
步骤五：true

疑问一：步骤一、步骤二很好理解，堆中地址与常量池中地址比较，然而步骤三就不好理解了，首先我去查看StringBuffer.append源代码如下：

    public synchronized StringBuffer append(String str) {
        this.toStringCache = null;
        super.append(str);
        return this;
    }

StringBuffer.toString()源代码如下

    public synchronized String toString() {
        if (this.toStringCache == null) {
            this.toStringCache = Arrays.copyOfRange(this.value, 0, this.count);
        }

        return new String(this.toStringCache, true);
    }

最终通过StringBuffer.toString()是生成一个堆内的String对象，然而结果是true

疑问二：添加步骤三得出的结果是false，我的想法是常量池问题吗？，所以我又加了步骤五，然而得出结论是true，并不是常量池的问题。

疑问三：常量池存在哪个区域？百度是五花八门。所以我倾向于如下，求确认：

  在jdk8中，移除了方法区，转而用Metaspace区(元空间)域替代，所以我们需要使用新的jvm参数：-XX:MaxMetaspaceSize=2M，依然运行如上代码，抛出：java.lang.OutOfMemoryError: Metaspace异常。同理说明运行时常量池是划分在Metaspace区域中。具体关于Metaspace区域的知识，请自行搜索。

对于上述疑问，如果有人看见，请帮我解惑一下，谢谢。（未来更新代表未解决）

总结

1. 只有使用引号包含文本的方式创建的String对象之间使用“+”连接产生的新对象才会被加入字符串池中,即对于所有包含new方式新建对象（包括null）或不可预料的变量用“+”连接，它所产生的新对象都不会被加入字符串池中（放进堆中）
2. intern方法会尝试将字符串添加到常量池中，并返回其在常量池中的地址（我认为调用intern方法首先会查询常量池有没有当前字符串，如果有就直接返回地址，否则先插入到常量池中然后返回地址）
3. 程序运行时，除非手动向常量池中添加常量(比如调用intern方法)，否则jvm不会自动添加常量到常量池
4. 必须要关注编译期的行为，才能更好的理解常量池。
5. 运行时常量池中的常量，基本来源于各个class文件中的常量池

RPSC-OSI系统下的