知识归纳笔记(一):考查常量池、堆、栈

常量池、堆、栈

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

 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,并不是常量池的问题。 

对于上述疑问

 

JDK1.7后,常量池被放入到堆空间中,这导致intern()函数的功能不同
 
JDK1.6及以前, 调用intern(), 如果常量池中不存在值相等的字符串时,jvm会复制一个字符串到创量池中,并返回常量池中的字符串。
 
JDK1.7及其后,intern 方法还是会先去查询常量池中是否有已经存在,如果存在,则返回常量池中的引用,这一点与之前的没有什么区别,区别在于,如果常量池找不到对应的字符串,则不会将字符串拷贝到常量池,而只在常量池中生成一个对原字符串的引用。

总结

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

RPSC-OSI系统下的

 

posted @ 2019-09-25 18:17  空留意  阅读(222)  评论(0编辑  收藏  举报