精华内容
下载资源
问答
  • 静态常量池
    2021-12-17 10:26:21

            静态常量池指的是java代码中定义的常量,经过jvm编译后形成在class文件中的常量区域。所以静态常量池指的是class文件内部。在堆中

            运行常量池指的是jvm运行中,将编译后的类放在metaspace区,具体包括class文件辕信息描述、编译后的代码数据、引用类型数据、类文件常量池等。在metaspace区

            字符串常量池指的是类加载完成后,经过验证、准备阶段之后放在字符串常量池中。字符串常量池的数据只会存储一份,被所有的类共享。基本流程是:创建字符串之前检查常量池中是否存在,如果有存在则获取其应用,如果不存在则创建并存入,并返回新对象的应用(如string.toIntern()方法)。在堆中

            静态变量是指由static修饰的变量,也是在堆中。

    package jvm;
    
    public class RuntimeConstantPoolOOM {
        public static void main(String args[]) {
            /*Set<String> set = new HashSet<String>();
        	short i = 0;
        	while(true) {
        		set.add(String.valueOf(i).intern());
        	}*/
        	String str1 = new StringBuffer("test").append("hello").toString();
        	System.out.println(str1.intern() == str1); //输出true
        	String str2 = "testdemo";
        	str2.intern();
        	String str3 = new StringBuffer("test").append("demo").toString();
        	System.out.print(str3.intern() == str3);//输出false
        }
    }
    

    更多相关内容
  • Java中的常量池,实际上分为两种形态:静态常量池和运行时常量池。1)所谓静态常量池,即*.class文件中的常量池,class文件中的常量池不仅仅包含字符串(数字)字面量,还包含类、方法的信息,占用class文件绝大部分...

    1、什么是常量

    用final修饰的成员变量表示常量,值一旦给定就无法改变!

    final修饰的变量有三种:静态变量、实例变量和局部变量,分别表示三种类型的常量。

    Java中的常量池,实际上分为两种形态:静态常量池和运行时常量池。

    1)所谓静态常量池,即*.class文件中的常量池,class文件中的常量池不仅仅包含字符串(数字)字面量,还包含类、方法的信息,占用class文件绝大部分空间。

    2)

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

    2、class字节码文件​

    ​class文件的@头4个字节称为魔数@,它的唯一作用就是确定这个文件时候是一个能被虚拟机接受的class文件。很多图片格式都用一个魔数来标识文件类型,比如png和jpg等。在java的class文件中,这个数是0xcafebabe。接下来就是class文件的版本号,第5、6个字节是@次版本号@,第7、8个字节是@主版本号@。在这里,次版本号是0,主版本号是52,(十六进制是34),紧接着主版本号的就是@常量池@,常量池可以理解为class文件的资源仓库,它是class文件结构中与其它项目关联最多的数据类型,也是占用class文件空间最大的数据项目之一,也是class文件中第一个出现的表类型数据项目。这些符号引用在虚拟机中如果不经过转换则无法与实际内存相连接,即无法被虚拟机直接使用,在虚拟机运行时,需要从常量池获得对应的符号引用,再在类创建时或运行时解析并翻译到具体的内存地址中。每项常量都是一个表,而由于各个常量的类型不一,大小也不相同,所以同样需要一个u1类型的数据来标记常量的类型,以确定其后的常量表的格式。

    常量池(constant_pool)指的是在编译期被确定,并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量,也包括字符串常量和符号引用。

    常量池主要用于存放两大类常量:字面量(Literal)和符号引用量(Symbolic

    References),字面量相当于Java语言层面常量的概念,如文本字符串,声明为final的常量值等,符号引用则属于编译原理方面的概念,包括了如下三种类型的常量:

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

    则没有实现。另外Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值在-128到127时才可使用对象池。

    ​在常量池之后,紧接着的2个字节代表@访问标志@,即在前面说到的,这个Class是类还是接口,是用哪个修饰符来修饰,abstract,public等,还有,如果是类的话,是否被声明为final,等等。

    访问标志之后,则是@类索引、父索引与接口索引@的集合。类索引和父类索引都是一个u2类型的数据,而接口索引集合是一组u2类型的数据的集合,Class文件中由这三项数据来确定这个类的继承关系。类索引用来确定这个类的全限定名,父类索引用于确定这个类的父类的全限定名,接口索引集合用来描述这个类实现了哪些接口,这些被实现的接口将按实现或继承的顺序从左到右的顺序排列在接口的索引集合中。类索引、父类索引和接口索引都按顺序排列在访问标志之后。

    接下来就是@字段表@了,此处字段表存的就是前文说的类成员变量或实例成员变量,但不包括方法内部声明的变量。如果类存在父类,则除非子类覆盖了父类的字段定义,否则在子类中不会列出从超类或父接口中继承而来的字段,但有可能列出原来java代码中不存在的字段,譬如在内部类为了保持对外部类的访问性,会自动添加指向外部类实例的字段。另外,java中是不允许出现相同的字段名的,但对于字节码来说,如果两个字段的描述符不一致,则字段重名是合法的。

    字段表之后就是@方法表@集了。方法表集合与字段表集合的结构形式几乎完全一致。此处,方法中的代码的存放位置则是方法表的属性表中的一项名为"Code"的属性里面。与字段表集合相对应的,如果父类方法在子类中没有被重写(Override),则方法表集合中就不会出现来自父类的方法信息。

    ​3、方法区中的运行时常量池

    运行时常量池是方法区的一部分。CLass文件中除了有类的版本、字段、方法、接口等描述信息外,还有一项信息是常量池,用于存放编译期生成的各种字面量和符号引用,这部分内容将在类加载后进入方法区的运行时常量池中存放。

    运行时常量池相对于CLass文件常量池的另外一个重要特征是具备动态性,方法。

    4、常量池的好处

    常量池是为了避免频繁的创建和销毁对象而影响系统性能,其实现了对象的共享。例如字符串常量池,在编译阶段就把所有的字符串文字放到一个常量池中。

    (1)节省内存空间:常量池中所有相同的字符串常量被合并,只占用一个空间。

    (2)节省运行时间:比较字符串时,==比equals()快。对于两个引用变量,只用==判断引用是否相等,也就可以判断实际值是否相等

    String s1=new String("abc"); 为例

    首先你要理解constant   pool,

    这是一个特殊的共享区域,literate,

    Class这些可以在内存中共享的不经常改变的东西,都可以放在这里。

    如果你用了String   s1

    =   new

    String("abc");

    那么,会有两个String被创建,一个是你的Class被CLassLoader加载时,你的"abc"被作为常量读入,在constant

    pool里创建了一个共享的"abc"

    然后,当调用到new

    String("abc")的时候,会在heap里创建这个new

    String("abc");

    考虑类加载阶段和实际执行时。

    (1)类加载对一个类只会进行一次。"abc"在类加载时就已经创建并驻留了(如果该类被加载之前已经有"abc"字符串被驻留过则不需要重复创建用于驻留的"xyz"实例)。驻留的字符串是放在全局共享的字符串常量池中的。

    (2)在这段代码后续被运行的时候,"abc"字面量对应的String实例已经固定了,不会再被重复创建。所以这段代码将常量池中的对象复制一份放到heap中,并且把heap中的这个对象的引用交给s1

    持有。

    这条语句创建了2个对象。

    展开全文
  • 常量池(运行时常量池 静态常量池

    千次阅读 多人点赞 2019-03-29 11:39:16
    深入浅出java常量池 理论 jvm虚拟内存分布: 程序计数器是jvm执行程序的流水线,存放一些跳转指令。 本地方法栈是jvm调用操作系统方法所使用的栈。 虚拟机栈是jvm执行java代码所使用的栈。 ...

    深入浅出java常量池

     

    理论

         

         jvm虚拟内存分布:

    jvm虚拟内存分布

     

         程序计数器是jvm执行程序的流水线,存放一些跳转指令。

         本地方法栈是jvm调用操作系统方法所使用的栈。

         虚拟机栈是jvm执行java代码所使用的栈。

         方法区存放了一些常量、静态变量、类信息等,可以理解成class文件在内存中的存放位置。

         虚拟机堆是jvm执行java代码所使用的堆。

     

         Java中的常量池,实际上分为两种形态:静态常量池运行时常量池

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

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

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

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

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

     

          常量池的好处
    常量池是为了避免频繁的创建和销毁对象而影响系统性能,其实现了对象的共享。
    例如字符串常量池,在编译阶段就把所有的字符串文字放到一个常量池中。
    (1)节省内存空间:常量池中所有相同的字符串常量被合并,只占用一个空间。
    (2)节省运行时间:比较字符串时,==比equals()快。对于两个引用变量,只用==判断引用是否相等,也就可以判断实际值是否相等。

     

     

         接下来我们引用一些网络上流行的常量池例子,然后借以讲解。

     

     1 String s1 = "Hello";
     2 String s2 = "Hello";
     3 String s3 = "Hel" + "lo";
     4 String s4 = "Hel" + new String("lo");
     5 String s5 = new String("Hello");
     6 String s6 = s5.intern();
     7 String s7 = "H";
     8 String s8 = "ello";
     9 String s9 = s7 + s8;
    10           
    11 System.out.println(s1 == s2);  // true
    12 System.out.println(s1 == s3);  // true
    13 System.out.println(s1 == s4);  // false
    14 System.out.println(s1 == s9);  // false
    15 System.out.println(s4 == s5);  // false
    16 System.out.println(s1 == s6);  // true

     

     

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

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

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

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

    配上一张简图理清思路:

    java字符串不变     

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

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

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

     

    • 特例1

     

    public static final String A = "ab"; // 常量A
    public static final String B = "cd"; // 常量B
    public static void main(String[] args) {
         String s = A + B;  // 将两个常量用+连接对s进行初始化 
         String t = "abcd";   
        if (s == t) {   
             System.out.println("s等于t,它们是同一个对象");   
         } else {   
             System.out.println("s不等于t,它们不是同一个对象");   
         }   
     } 
    s等于t,它们是同一个对象

     

    A和B都是常量,值是固定的,因此s的值也是固定的,它在类被编译时就已经确定了。也就是说:String s=A+B; 等同于:String s="ab"+"cd";

    • 特例2

     

    public static final String A; // 常量A
    public static final String B;    // 常量B
    static {   
         A = "ab";   
         B = "cd";   
     }   
     public static void main(String[] args) {   
        // 将两个常量用+连接对s进行初始化   
         String s = A + B;   
         String t = "abcd";   
        if (s == t) {   
             System.out.println("s等于t,它们是同一个对象");   
         } else {   
             System.out.println("s不等于t,它们不是同一个对象");   
         }   
     } 
    s不等于t,它们不是同一个对象

     

    A和B虽然被定义为常量,但是它们都没有马上被赋值。在运算出s的值之前,他们何时被赋值,以及被赋予什么样的值,都是个变数。因此A和B在被赋值之前,性质类似于一个变量。那么s就不能在编译期被确定,而只能在运行时被创建了。

     

         至此,我们可以得出三个非常重要的结论:

     

               必须要关注编译期的行为,才能更好的理解常量池。

               运行时常量池中的常量,基本来源于各个class文件中的常量池。(运行是常量池是静态常量池的各种集合一般而言不会另外自动增加常量在常量池中)

               程序运行时,除非手动向常量池中添加常量(比如调用intern方法),否则jvm不会自动添加常量到常量池。

          以上所讲仅涉及字符串常量池,实际上还有整型常量池、浮点型常量池(java中基本类型的包装类的大部分都实现了常量池技术,即Byte,Short,Integer,Long,Character,Boolean两种浮点数类型的包装类Float,Double并没有实现常量池技术) 等等,但都大同小异,只不过数值类型的常量池不可以手动添加常量,程序启动时常量池中的常量就已经确定了,比如整型常量池中的常量范围:-128~127,(Byte,Short,Integer,Long,Character,Boolean)这5种包装类默认创建了数值[-128,127]的相应类型的缓存数据,但是超出此范围仍然会去创建新的对象。

    例如在自动装箱时,把int变成Integer的时候,是有规则的,当你的int的值在-128-IntegerCache.high(127) 时,返回的不是一个新new出来的Integer对象,而是一个已经缓存在堆 中的Integer对象,(我们可以这样理解,系统已经把-128到127之 间的Integer缓存到一个Integer数组中去了,如果你要把一个int变成一个Integer对象,首先去缓存中找,找到的话直接返回引用给你就 行了,不必再新new一个),如果不在-128-IntegerCache.high(127) 时会返回一个新new出来的Integer对象。           

     

    实践

         

         说了这么多理论,接下来让我们触摸一下真正的常量池。

         前文提到过,class文件中存在一个静态常量池,这个常量池是由编译器生成的,用来存储java源文件中的字面量(本文仅仅关注字面量),假设我们有如下java代码:

     

    1 String s = "hi";

     

         为了方便起见,就这么简单,没错!将代码编译成class文件后,用winhex打开二进制格式的class文件。如图:

     二进制格式的class文件

     

         简单讲解一下class文件的结构,开头的4个字节是class文件魔数,用来标识这是一个class文件,说白话点就是文件头,既:CA FE BA BE。

         紧接着4个字节是java的版本号,这里的版本号是34,因为笔者是用jdk8编译的,版本号的高低和jdk版本的高低相对应,高版本可以兼容低版本,但低版本无法执行高版本。所以,如果哪天读者想知道别人的class文件是用什么jdk版本编译的,就可以看这4个字节。

         接下来就是常量池入口,入口处用2个字节标识常量池常量数量,本例中数值为00 1A,翻译成十进制是26,也就是有25个常量,其中第0个常量是特殊值,所以只有25个常量。

         常量池中存放了各种类型的常量,他们都有自己的类型,并且都有自己的存储规范,本文只关注字符串常量,字符串常量以01开头(1个字节),接着用2个字节记录字符串长度,然后就是字符串实际内容。本例中为:01 00 02 68 69。

         接下来再说说运行时常量池,由于运行时常量池在方法区中,我们可以通过jvm参数:-XX:PermSize、-XX:MaxPermSize来设置方法区大小,从而间接限制常量池大小。

         假设jvm启动参数为:-XX:PermSize=2M -XX:MaxPermSize=2M,然后运行如下代码:

     

    1 //保持引用,防止自动垃圾回收
    2 List<String> list = new ArrayList<String>();
    3         
    4 int i = 0;
    5         
    6 while(true){
    7     //通过intern方法向常量池中手动添加常量
    8     list.add(String.valueOf(i++).intern());
    9 }

     

         程序立刻会抛出:Exception in thread "main" java.lang.outOfMemoryError: PermGen space异常。PermGen space正是方法区,足以说明常量池在方法区中。

    展开全文
  • 小菜先拙劣的表达一下jvm虚拟内存分布: 程序计数器是jvm执行程序的流水线,存放一些跳转... 方法区存放了一些常量静态变量、类信息等,可以理解成class文件在内存中的存放位置。 虚拟机堆是jvm执行jav...

     小菜先拙劣的表达一下jvm虚拟内存分布:

    jvm虚拟内存分布

     

         程序计数器是jvm执行程序的流水线,存放一些跳转指令,这个太高深,小菜不懂。

         本地方法栈是jvm调用操作系统方法所使用的栈。

         虚拟机栈是jvm执行java代码所使用的栈。

         方法区存放了一些常量、静态变量、类信息等,可以理解成class文件在内存中的存放位置。

         虚拟机堆是jvm执行java代码所使用的堆。

         Java中的常量池,实际上分为两种形态:静态常量池运行时常量池

         所谓静态常量池,即*.class文件中的常量池,class文件中的常量池不仅仅包含字符串(数字)字面量,还包含类、方法的信息,占用class文件绝大部分空间。

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

         接下来我们引用一些网络上流行的常量池例子,然后借以讲解。

     

     

     1 String s1 = "Hello";
     2 String s2 = "Hello";
     3 String s3 = "Hel" + "lo";
     4 String s4 = "Hel" + new String("lo");
     5 String s5 = new String("Hello");
     6 String s6 = s5.intern();
     7 String s7 = "H";
     8 String s8 = "ello";
     9 String s9 = s7 + s8;
    10           
    11 System.out.println(s1 == s2);  // true
    12 System.out.println(s1 == s3);  // true
    13 System.out.println(s1 == s4);  // false
    14 System.out.println(s1 == s9);  // false
    15 System.out.println(s4 == s5);  // false
    16 System.out.println(s1 == s6);  // true

     

     

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

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

         s1 == s3这个地方有个坑,s3虽然是动态拼接出来的字符串,但是所有参与拼接的部分都是已知的字面量,在编译期间,这种拼接会被优化,编译器直接帮你拼好,因此String s3 = "Hel" + "lo";在class文件中被优化成String s3 = "Hello";,所以s1 == s3成立。

         s1 == s4当然不相等,s4虽然也是拼接出来的,但new String("lo")这部分不是已知字面量,是一个不可预料的部分,编译器不会优化,必须等到运行时才可以确定结果,结合字符串不变定理,鬼知道s4被分配到哪去了,所以地址肯定不同。配上一张简图理清思路:

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

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

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

         至此,我们可以得出三个非常重要的结论:

     

               必须要关注编译期的行为,才能更好的理解常量池。

               运行时常量池中的常量,基本来源于各个class文件中的常量池。

               程序运行时,除非手动向常量池中添加常量(比如调用intern方法),否则jvm不会自动添加常量到常量池。

     

         以上所讲仅涉及字符串常量池,实际上还有整型常量池、浮点型常量池等等,但都大同小异,只不过数值类型的常量池不可以手动添加常量,程序启动时常量池中的常量就已经确定了,比如整型常量池中的常量范围:-128~127,只有这个范围的数字可以用到常量池。

     

     

    静态常量池和动态常量池的关系以及区别

    静态常量池存储的是当class文件被java虚拟机加载进来后存放在方法区的一些字面量和符号引用,字面量包括字符串,基本类型的常量,符号引用其实引用的就是常量池里面的字符串,但符号引用不是直接存储字符串,而是存储字符串在常量池里的索引。

    动态常量池是当class文件被加载完成后,java虚拟机会将静态常量池里的内容转移到动态常量池里,在静态常量池的符号引用有一部分是会被转变为直接引用的,比如说类的静态方法或私有方法,实例构造方法,父类方法,这是因为这些方法不能被重写其他版本,所以能在加载的时候就可以将符号引用转变为直接引用,而其他的一些方法是在这个方法被第一次调用的时候才会将符号引用转变为直接引用的。

    总结:

    方法区里存储着class文件的信息和动态常量池,class文件的信息包括类信息和静态常量池。可以将类的信息是对class文件内容的一个框架,里面具体的内容通过常量池来存储。

    动态常量池里的内容除了是静态常量池里的内容外,还将静态常量池里的符号引用转变为直接引用,而且动态常量池里的内容是能动态添加的。例如调用String的intern方法就能将string的值添加到String常量池中,这里String常量池是包含在动态常量池里的,但在jdk1.8后,将String常量池放到了堆中。

     

     

         

    展开全文
  • 最近学习了JVM原理,遇到了运行时常量池的区域定义,他是属于JVM运行时内存模型方法区中的一部分,总体分布如下图:如下图:整体分布如下 而运行、静态常量池是属于方法区的一部分,一般我通常说的是运行时的常量区...
  • 1.静态常量池 定义:是指程序在加载的时候自动将此程序中保存的字符串等信息全部进行分配 示例: String strA = "www.baidu.com"; String strB = "www." + "baidu" + ".com"; System.out.println(strA == strB); ...
  • 静态常量池和运行时常量池的区别: 静态常量池是针对每个被加载进入内存的class文件解析后,存放各个字面量值,符号引用的数据。简而言之,静态常量池属于某个类的字节码文件,属于单个类的自己的常量池。 运行时...
  • 方法区与Java堆一样,是各个线程共享的内存区域,它用于存储已经被虚拟机加载的类型信息、常量静态变量、即时编译器编译后的代码缓存等数据。 他也有一个别名为"非堆",目的是与Java堆区分开来。 方法区和永久代 ...
  • Java中的常量池,实际上分为两种形态:静态常量池和运行时常量池。 所谓静态常量池,即*.class文件中的常量池,class文件中的常量池不仅仅包含字符串(数字)字面量,还包含类、方法的信息,占用class文件绝大部分...
  • 方法区 和 运行时常量池 class文件详解
  • 字符串常量池(String Poll) java6: ...静态常量池(class文件常量池) 用于存放编译器生成的各种字面量(Literal)和符号引用(Symbolic References)。 字面量:文本字符串int long 等基本类型...
  • 【番外篇】本篇核心:JDK各个版本中JDK的运行时常量池、字符串常量池、静态常量池的功能及存储位置。 在写本系列文章时,发现一旦追究起底层实现都会涉及到一些内存结构的问题。其中涉及比较多的便是常量池,本篇...
  • 主要介绍了C#之CLR内存字符串常量池(string),对于学习和理解C#内存原理很有帮助,需要的朋友可以参考下
  • java 常量池静态变量详解

    千次阅读 2021-03-03 13:42:43
    Java中的常量池,实际上分为两种形态:静态常量池和运行时常量池。所谓静态常量池,即*.class文件中的常量池,class文件中的常量池不仅仅包含字符串(数字)字面量,还包含类、方法的信息,占用class文件绝大部分空间...
  • java中常量以及常量池

    2020-12-22 19:39:53
    1、举例说明 变量 常量 字面...  静态常量池:*.class文件中的常量池,class文件中的常量池不仅仅包含字符串,数值字面量,还包含类、方法的信息,占用class文件绝大部分空间。  运行时常量池:是jvm虚拟机在完成类装
  • 1、什么是常量 用final修饰的成员变量表示常量,值一旦给定就无法改变! ...1)所谓静态常量池,即*.class文件中的常量池,class文件中的常量池不仅仅包含字符串(数字)字面量,还包含类、方法的...
  • (静态)常量池:用于存放编译器生成的各种字面量和符号引用(符号引用区别于直接引用,后者在class...相对于静态常量池,运行时常量池具有动态性,在程序运行的时候可能将新的常量放入运行时常量池中,比如使用St...
  • 3、常量池: 静态常量池:指的是程序(*.class)在加载前自动将此程序之中的字符串、普通常量、类和方法的信息分配至静态常量池 运行时常量池:当一个程序(*.class)加载之后,常量中含有变量,分配到运行时常量池
  • 关于这部分的详细信息可以看下这篇博客:https://blog.csdn.net/seu_calvin/article/details/52291082 前面一种常量池,叫静态常量池,后面一种常量池,叫动态常量池。很明显,系统里面一开始肯定是没有...
  • 如果大家比较了解class文件的话,应该会知道class文件中最重要的是常量池,类的所有属性,包括字段名、方法名等等的值都存储在class文件的常量池中,这里的常量池就是我们所说的静态常量池。这时类属性对class文件...
  • 一文让你彻底搞懂final、static、static final、常量池、静态常量池、运行时常量池、成员变量、实例变量、静态变量、类变量
  • 静态常量池

    2020-07-22 15:13:58
    静态静态变量(又叫类变量,有static修饰)和静态方法存放在静态区; 使用某一个类的时候,需要将该类的字节码文件加载到元空间; 在加载的过程中,会先检查类中有没有static修饰的成员; 如果有,就会优先将...
  • 详解JVM的常量池

    2022-05-24 13:32:19
    静态常量池也可以称为Class常量池,也就是每个.java文件经过编译后生成的.class文件,每个.class文件里面都包含了一个常量池,因为这个常量池是在Class文件里面定义的,也就是.java文件编译后就不会在变了,也不能...
  • Java 常量池

    千次阅读 2021-12-11 14:34:15
    1、 Class 常量池常量池(静态常量池) Java 文件被编译成 Class 文件,Class 文件中除了包含类的版本、字段、方法、接口等描述信息外,还有一项就是 Class 常量池,Class 常量池是当 Class 文件被 Java 虚拟机加载...
  • 1.观察String静态常量池 public class StaticConstantPool { public static void main(String[] args) { String a = "www.cww.site"; String b = "www."+"cww."+"site"...
  • 1、常量 常量在java中就值的是一般的字面量,比如字符串,整数,浮点数等等数据。简单理解java中什么叫常量 2、常量池,也叫静态常量池,说常量池一定要指明是编译器生产
  • Java 常量池详解(一)字符串常量池 2.class文件常量池(class constant pool) 产生时机:当java文件被编译成class文件之后,就会生成class常量池,跟jvm 无关系 常量池主要存放两大类常量:字面量;符号引用 字面...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 112,778
精华内容 45,111
关键字:

静态常量池

友情链接: 超声波避障.zip