第46节：Java当中的常量池

浅浅的花香味﹌ 2021-09-16 09:58 326阅读 0赞

![标题图][1240]

## Java当中的常量池 ##

在`Java`虚拟机`jvm`中，内存分布为：**虚拟机堆，程序计数器，本地方法栈，虚拟机栈，方法区。**

![JVM内存模型.png][JVM_.png]

程序计数器是`jvm`执行程序的流水线，是用来存放一些指令的，本地方法栈是`jvm`操作系统方法所使用的栈，而虚拟机栈是用来执行程序代码的栈，在方法区中有**类变量，类信息，方法信息，常量池（符号的引用，以表的形式存在的）**，堆是虚拟机执行程序代码的所用的堆。

\*\*常量？\*\*是一旦给定了值就无法改变的量，用final修饰的成员变量为常量。

> 什么是`class`文件常量池？

我们知道在`class`文件中，**有类的版本信息，字段信息，方法，接口等信息，还有一个就是常量池，** 这个就是`class`文件常量池了。

`class`文件常量池主要用于存放的是什么呢？

存储的是编译生成的**各种字面量**和**符号引用**。在计算机科学中，字面量是用于表达源代码中固定值的表示法；而符号引用是一组符号用来描述所引用的目标，可以是任何形式的字面量，只要使用时能够无歧义的定位到目标就行。

常量池是以表的形式存在（表是用来存储字符串值的，不存储符号引用），\*\*实际可以分两种，一种为静态常量池，另一种为运行时常量池，\*\*共有`11`中常量表，常量池的每一个常量都代表一张表。

> 常量表

<table> 
 <thead> 
  <tr> 
   <th>常量表类型</th> 
   <th>标志值</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>CONSTANT_Utf8</td> 
   <td>1</td> 
   <td>UTF-8编码的Unicode字符串</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_Integer</td> 
   <td>3</td> 
   <td>int类型的字面值</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_Float</td> 
   <td>4</td> 
   <td>float类型的字面值</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_Long</td> 
   <td>5</td> 
   <td>long类型的字面值</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_Double</td> 
   <td>6</td> 
   <td>double类型的字面值</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_Class</td> 
   <td>7</td> 
   <td>对一个类或者是接口的符号引用</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_String</td> 
   <td>8</td> 
   <td>String类型的字面值的引用</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_Fieldref</td> 
   <td>9</td> 
   <td>对一个字段的符号</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_Methodref</td> 
   <td>10</td> 
   <td>对一个类中方法的符号应用</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_InterfaceMethodref</td> 
   <td>11</td> 
   <td>对一个接口中方法的符号引用</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_NameAndType</td> 
   <td>12</td> 
   <td>对一个字段或方法的部分符号引用</td> 
  </tr> 
 </tbody> 
</table>

> 常量池

Integer integer1 = 127;
    Integer integer2 = 127;
    System.out.println(integer1 == integer2);
    // true
    Integer integer1 = 128;
    Integer integer2 = 128;
    System.out.println(integer1 == integer2);
    // false

在`Java`中符号`“==”`是用来比较地址，符号`“equals”`默认是与符号`“==”`一样，都是用来比较地址的。

String string1 = "dashu";
    String string2 = "dashu";
    System.out.println(string1==string2);
    // true

String string1 = "dashu";
    String string3 = new String("dashu");
    System.out.println(string1 == string3);
    // false

> `String str = new String("dashu");` 创建了几个对象呢？  
> 答案是：2个或者1个。

在`new String("dashu");`，如果这个`“dashu”`字面值已经出现在常量池中，那么就只出创建一个对象，如果没有就创建两个对象。

**原理：** 出现了字面量`“dashu”`，系统会到字符串常量池中查找是否有相同的字符串存在，如果有，就不会创建新的对象了，否则就会用字面量值`“dashu”`，创建一个`String`对象。而`new String("dashu")`，有关键字`new`的存在，就表示它一定会创建一个新的对象，然后调用接收`String`参数的构造器进行初始化。

如果改为`string1 == string3.intern()`结果为`true`，因为返回的是常量池里面字面值的地址。

> 栈：线程栈和本地方法栈

// 源码
    public class Object{
     private static native void registerNatives();
     static{
      registerNatives();
     }
    }
    // 源码
    public boolean equals(Object obj){
     return (this == obj);
    }
    // 源码
    public String toString(){
     return getClass().getName() + "@" + Integer.toHexString(hasCode());
    }
    // 源码
    protected native Object clone() throws CloneNotSupportedException;

有`native`修饰符修饰的是通过`JNI`来调用`c`语言或是`c++`执行的。

所有的类都是`Object`的子类。

万物皆对象
    // 源码注解
    Class {@code Object} is the root of the  class hierarchy.
    Every class has {@code Object} as a superclass.
    All objects, including arrays, implements the methods of this class.
    @ see java.lang Class
    @ since JDK1.0

> 常量池：  
> `Class`文件中存储所有常量  
> 在`Java`中说过常量池可以分两种形态，**静态常量池和运行时常量池**。

**静态常量池**就是`class`文件中的常量池有字符串字面量，类信息，方法的信息等，占用了`class`文件较大部分的空间，在常量池中主要存放的是字面量和符号引用量。

**运行时常量池**是`java`虚拟机在完成类加载后的操作，将`class`文件中的常量池加载到内存中，并保证在方法区，我们口中的常量池是在方法区中运行的常量池，运行时常量池具有动态性，在运行期间也能产生新的常量放入池中，就是上方写过的代码。常量不一定要在编译期间产生，也可以在运行期间产生新的产量放入到池中。

> 如下解析：

`Java`虚拟机`jvm`在执行某个类的时候，要经过类从加载到内存中，到卸载为止。

整个过程为 **加载，验证，准备，解析，初始化，使用，卸载。**

*  加载，
 *  验证，`class`文件的版本是否能兼容当前的`Java`虚拟机版本，然后`class`文件要满足虚拟机的规范。
 *  准备，需要准备什么呢？  
    就是要进行类成员的初始化为初始值，其中为`final`修饰的类变量除外，`final`变量就直接初始化为变量值，而类成员不一样。
 *  解析，什么是解析呢？  
    就是把符号引用解析为直接引用，就是我们变量`xxx`，这种代表变为直接引用，什么是直接引用呢？就是内存地址，如我们常见的`xxx0203r0e`，这种。
 *  初始化，把关于`static`修饰的变量或者是`static`静态代码块按照顺序组成构造器进行初始化变量。
 *  使用，
 *  卸载

当类加载到内存后，`jvm`会将`class`常量池中的内容存放到运行时常量池中，所以运行时常量池每个类都有一个的。

`class`常量池是存放字面量和符号的引用，是对象的符号引用值，经过解析就是把符号引用解析为直接引用，在编译阶段存放的是常量的符号引用，进行解析后就是直接引用了。然后在全局常量池中保证每个`jvm`只有一份，存放的是字符串常量的直接引用值。

如果改为`string1 == string3.intern()`结果为true，因为返回的是常量池里面字面值的地址。

`String`类的`intern()`方法，会在常量池中查找是否有一份`equal()`相等的字符串。

String string1 = "dashu";
    String string3 =  new String("dashu");
    System.out.println(string1==string3.intern());

如果常量池中没有这个`“dashu”`字面量，那么就先把这个字面量`“dashu”`值，先放入到常量表之后，再返回常量表的地址。

> 常量池优点

常量池可以避免因频繁的创建和销毁对象，从而导致系统性能的降低，也实现了对象的共享，即可以节省内存空间，也可以节省运行的时间。

> 往后余生，唯独有你  
> 简书作者：达叔小生  
> 90后帅气小伙，良好的开发习惯；独立思考的能力；主动并且善于沟通  
> 简书博客： [https://www.jianshu.com/u/c785ece603d1][https_www.jianshu.com_u_c785ece603d1]

## 结语 ##

*  下面我将继续对 其他知识 深入讲解 ，有兴趣可以继续关注
 *  小礼物走一走 or 点赞

[1240]: /images/20210724/248b01d3a80f4f70912cb9e661005fe5.png
[JVM_.png]: /images/20210724/b9b63aca74ff41259d426e3c04a70ed5.png
[https_www.jianshu.com_u_c785ece603d1]: https://www.jianshu.com/u/c785ece603d1