探究Java常量本质及三种常量池(小结)

更新时间：2019年09月29日 10:17:23 作者：沉晓

这篇文章主要介绍了探究Java常量本质及三种常量池(小结)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

之前从他人的博文，还有一些书籍中了解到常量是放在常量池中,细节的内容无从得知，总觉得面前的东西是一个几乎完全的黑盒，总是觉得不舒服，于是就翻阅《深入理解Java虚拟机》，这本书中对常量的介绍更多地偏重于字节码文件的结构，还有在自动内存管理机制中也介绍了运行时常量池, 查阅资料后脑海中有了一定的认识。

Java中的常量池分为三种形态：静态常量池，字符串常量池以及运行时常量池。

静态常量池

所谓静态常量池，即*.class文件中的常量池，class文件中的常量池不仅仅包含字符串(数字)字面量，还包含类、方法的信息，占用class文件绝大部分空间。
这种常量池主要用于存放两大类常量：字面量(Literal)和符号引用量(Symbolic References)，字面量相当于Java语言层面常量的概念，如文本字符串，声明为final的常量值等，符号引用则属于编译原理方面的概念，包括了如下三种类型的常量：

类和接口的全限定名
字段名称和描述符
方法名称和描述符

而运行时常量池，则是jvm虚拟机在完成类装载操作后，将class文件中的常量池载入到内存中，并保存在方法区中，我们常说的常量池，就是指方法区中的运行时常量池。

运行时常量池相对于Class文件常量池的另外一个重要特征是具备动态性，Java语言并不要求常量一定只有编译期才能产生，也就是并非预置入class文件中常量池的内容才能进入方法区运行时常量池，运行期间也可能将新的常量放入池中，这种特性被开发人员利用比较多的就是String类的intern()方法。

String的intern()方法会查找在常量池中是否存在一份equal相等的字符串,如果有则返回该字符串的引用,如果没有则添加自己的字符串进入常量池。

那这样来看，通过静态常量池，即*.class文件中的常量池更能够探究常量的含义了

下面看一段代码

public class Main {

  public static void main(String[] args) {
    System.out.println(Father.str);
  }
}

class Father{
  public static String str = "Hello,world";
  static {
    System.out.println("Father static block");
  }
}

输出结果为

再看另一个：

package com.company;

public class Main {

  public static void main(String[] args) {
    System.out.println(Father.str);
  }
}

class Father{
  public static final String str = "Hello,world";
  static {
    System.out.println("Father static block");
  }
}

结果：

只有一个

是不是发现很吃惊啊

我们对第二个演示的代码块进行反编译一下

D:\CodePractise\untitled\out\production\untitled\com\company>javap -c Main.class
Compiled from "Main.java"
public class com.company.Main {
 public com.company.Main();
  Code:
    0: aload_0
    1: invokespecial #1         // Method java/lang/Object."<init>":()V
    4: return

 public static void main(java.lang.String[]);
  Code:
    0: getstatic   #2         // Field java/lang/System.out:Ljava/io/PrintStream;
    3: ldc      #4         // String Hello,world
    5: invokevirtual #5         // Method java/io/PrintStream.println:(Ljava/lang/String;)V
    8: return
}

这里有一个Main()是构造方法下面的是main方法

0: getstatic # 2 对应的是System.out
3: ldc #4 对应的值直接是 Hello,world 了确定的值没有从Father类中取出

ldc表示将int，float或是String类型的常量值从常量池中推送至栈顶

竟然没有！！！即使删除Father.class文件这段代码照样可以运行它和Father类没有半毛钱的关系了

实际上，在编译阶段常量就会被存入到调用这个常量的方法所在的类的常量池当中

从这个例子中可以看出这里的str 是一个常量调用这个常量的方法是main方法 main方法所在的类是Main ，也就是说编译之后str被放在了该类的常量池中

本质上，调用类并没有直接引用到定义常量的类，因此并不会触发定义常量的类的初始化

类的初始化涉及到类的加载机制这里暂时写不说这个留到之后必须要好好说说

字符串常量池（string pool也有叫做string literal pool）

全局字符串池里的内容是在类加载完成，经过验证，准备阶段之后在堆中生成字符串对象实例，然后将该字符串对象实例的引用值存到string pool中（记住：string pool中存的是引用值而不是具体的实例对象，具体的实例对象是在堆中开辟的一块空间存放的。）。

字符串常量池的位置的说法不太准确
在JDK6.0及之前版本，字符串常量池是放在Perm Gen区(也就是方法区)中；
在JDK7.0版本，字符串常量池被移到了堆中了。

在HotSpot VM里实现的string pool功能的是一个StringTable类，它是一个哈希表，里面存的是驻留字符串(也就是我们常说的用双引号括起来的)的引用（而不是驻留字符串实例本身），也就是说在堆中的某些字符串实例被这个StringTable引用之后就等同被赋予了”驻留字符串”的身份。这个StringTable在每个HotSpot VM的实例只有一份，被所有的类共享。

回到运行常量池（runtime constant pool）

jvm在执行某个类的时候，必须经过加载、连接、初始化，而连接又包括验证、准备、解析三个阶段。

而当类加载到内存中后，jvm就会将静态常量池中的内容存放到运行时常量池中，由此可知，运行时常量池也是每个类都有一个。

静态常量池中存的是字面量和符号引用，也就是说它们存的并不是对象的实例，而是对象的符号引用值。而经过解析（resolve）之后，也就是把符号引用替换为直接引用，解析的过程会去查询字符串常量池，也就是我们上面所说的StringTable，以保证运行时常量池所引用的字符串与字符串常量池中所引用的是一致的。

我们看一个例子

import java.util.UUID;

public class Test {
  public static void main(String[] args) {
    System.out.println(TestValue.str);
  }
}

class TestValue{
  public static final String str = UUID.randomUUID().toString();

  static {
    System.out.println("TestValue static code");
  }
}

结果：

从声明本身str都是常量，关键的是这个常量的值能否在编译时期确定下来，显然这里的例子在编译期的时候显然是确定不下来的。需要在运行期才能能够确定下来，这要求目标类要进行初始化

当常量的值并非编译期间可以确定的，那么其值不会被放到调用类的常量池中
这时在程序运行时，会导致主动使用这个常量所在的类，显然会导致这个类被初始化。
（这个涉及到类的加载机制，后面会写这里做个标记）

反编译探究一下：

Compiled from "Test.java"
class com.leetcodePractise.tstudy.TestValue {
 public static final java.lang.String str;

 com.leetcodePractise.tstudy.TestValue();
  Code:
    0: aload_0
    1: invokespecial #1         // Method java/lang/Object."<init>":()V
    4: return

 static {};
  Code:
    0: invokestatic #2         // Method java/util/UUID.randomUUID:()Ljava/util/UUID;
    3: invokevirtual #3         // Method java/util/UUID.toString:()Ljava/lang/String;
    6: putstatic   #4         // Field str:Ljava/lang/String;
    9: getstatic   #5         // Field java/lang/System.out:Ljava/io/PrintStream;
   12: ldc      #6         // String TestValue static code
   14: invokevirtual #7         // Method java/io/PrintStream.println:(Ljava/lang/String;)V
   17: return
}

很明显TestValue类会初始化出来

常量介绍完之后这里记录一下反编译及助记符的笔记

package com.company;

public class Main {

  public static void main(String[] args) {
    System.out.println(Father.str);
    System.out.println(Father.s);
  }
}

class Father{
  public static final String str = "Hello,world";
  public static final short s = 6;
  static {
    System.out.println("Father static block");
  }
}

public class com.company.Main {
 public com.company.Main();
  Code:
    0: aload_0
    1: invokespecial #1         // Method java/lang/Object."<init>":()V
    4: return

 public static void main(java.lang.String[]);
  Code:
    0: getstatic   #2         // Field java/lang/System.out:Ljava/io/PrintStream;
    3: ldc      #4         // String Hello,world
    5: invokevirtual #5         // Method java/io/PrintStream.println:(Ljava/lang/String;)V
    8: getstatic   #2         // Field java/lang/System.out:Ljava/io/PrintStream;
   11: bipush    6
   13: invokevirtual #6         // Method java/io/PrintStream.println:(I)V
   16: return
}

bipush 表示将单字节（-128-127）的常量值推送至栈顶

再加入

package com.company;

public class Main {

  public static void main(String[] args) {
    System.out.println(Father.str);
    System.out.println(Father.s);
    System.out.println(Father.t);
  }
}

class Father{
  public static final String str = "Hello,world";
  public static final short s = 6;
  public static final int t = 128;
  static {
    System.out.println("Father static block");
  }
}

进行反编译

public class com.company.Main {
 public com.company.Main();
  Code:
    0: aload_0
    1: invokespecial #1         // Method java/lang/Object."<init>":()V
    4: return

 public static void main(java.lang.String[]);
  Code:
    0: getstatic   #2         // Field java/lang/System.out:Ljava/io/PrintStream;
    3: ldc      #4         // String Hello,world
    5: invokevirtual #5         // Method java/io/PrintStream.println:(Ljava/lang/String;)V
    8: getstatic   #2         // Field java/lang/System.out:Ljava/io/PrintStream;
   11: bipush    6
   13: invokevirtual #6         // Method java/io/PrintStream.println:(I)V
   16: getstatic   #2         // Field java/lang/System.out:Ljava/io/PrintStream;
   19: sipush    128
   22: invokevirtual #6         // Method java/io/PrintStream.println:(I)V
   25: return
}

sipush表示将一个短整型常量值（-32768~32767）推送至栈顶

再进行更改

package com.company;

public class Main {

  public static void main(String[] args) {
    System.out.println(Father.str);

    System.out.println(Father.t);
  }
}

class Father{
  public static final String str = "Hello,world";

  public static final int t = 1;
  static {
    System.out.println("Father static block");
  }
}

public class com.company.Main {
 public com.company.Main();
  Code:
    0: aload_0
    1: invokespecial #1         // Method java/lang/Object."<init>":()V
    4: return

 public static void main(java.lang.String[]);
  Code:
    0: getstatic   #2         // Field java/lang/System.out:Ljava/io/PrintStream;
    3: ldc      #4         // String Hello,world
    5: invokevirtual #5         // Method java/io/PrintStream.println:(Ljava/lang/String;)V
    8: getstatic   #2         // Field java/lang/System.out:Ljava/io/PrintStream;
   11: bipush    6
   13: invokevirtual #6         // Method java/io/PrintStream.println:(I)V
   16: getstatic   #2         // Field java/lang/System.out:Ljava/io/PrintStream;
   19: sipush    128
   22: invokevirtual #6         // Method java/io/PrintStream.println:(I)V
   25: return
}

D:\CodePractise\untitled\out\production\untitled\com\company>javap -c Main.class
Compiled from "Main.java"
public class com.company.Main {
 public com.company.Main();
  Code:
    0: aload_0
    1: invokespecial #1         // Method java/lang/Object."<init>":()V
    4: return

 public static void main(java.lang.String[]);
  Code:
    0: getstatic   #2         // Field java/lang/System.out:Ljava/io/PrintStream;
    3: ldc      #4         // String Hello,world
    5: invokevirtual #5         // Method java/io/PrintStream.println:(Ljava/lang/String;)V
    8: getstatic   #2         // Field java/lang/System.out:Ljava/io/PrintStream;
   11: iconst_1
   12: invokevirtual #6         // Method java/io/PrintStream.println:(I)V
   15: return
}

这里变成了 iconst_1

iconst 1表示将int类型1推送至栈顶（iconst_m1-iconst_5）
当大于5的时候就变为了bipush
m1对应的是-1

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

Mybatis应用mysql存储过程查询数据实例
下面小编就为大家分享一篇Mybatis应用mysql存储过程查询数据实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2017-12-12
JAVA时间存储类Period和Duration使用详解
这篇文章主要为大家介绍了JAVA时间存储类Period和Duration使用详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-09-09
java安全编码指南之:声明和初始化说明
这篇文章主要介绍了java安全编码指南之:声明和初始化说明，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2020-09-09
Java算法设计与分析分治算法
这篇文章主要介绍了Java算法设计与分析分治算法，一般分治算法在正文中分解为两个即以上的递归调用，并且子类问题一般是不想交的
2022-07-07
解决rror updating database.Cause:java.sql.SQLSyntaxE
这篇文章主要介绍了解决rror updating database.Cause:java.sql.SQLSyntaxErrorException问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2024-05-05
spring单例如何改多例
这篇文章主要介绍了spring单例如何改多例，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-01-01
Java面试题冲刺第二十一天--JVM
这篇文章主要为大家分享了最有价值的三道关于JVM的面试题，涵盖内容全面，包括数据结构和算法相关的题目、经典面试编程题等，感兴趣的小伙伴们可以参考一下
2021-08-08
利用Java设置Word文本框中的文字旋转方向的实现方法
Word文档中可添加文本框,并设置文本框为横向文本排列或是纵向文本排列,或者设置文本框中的文字旋转方向等.通过Java程序代码,也可以实现以上文本框的操作.下面以Java代码示例展示具体的实现步骤.另外,可参考C#及VB.NET代码的实现方法,需要的朋友可以参考下
2021-06-06
MyBatis连接数据库配置的基本步骤和机制
MyBatis 是一个流行的持久层框架,它通过使用XML或注解的方式将SQL语句、存储过程和Java方法进行绑定,从而避免了手写大量的JDBC代码和手动设置参数与结果集,本文给大家介绍了MyBatis连接数据库配置的基本步骤和机制,需要的朋友可以参考下
2024-05-05
Mybatis-plus动态条件查询QueryWrapper的使用案例
mybatis-plus框架功能很强大,把很多功能都集成了,下面这篇文章主要给大家介绍了关于Mybatis-plus动态条件查询QueryWrapper的使用教程,文中通过图文介绍的非常详细,需要的朋友可以参考下
2022-07-07

探究Java常量本质及三种常量池(小结)

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具