（二）常量池的探索

已于 2023-01-12 23:08:23 修改
阅读量76 收藏
点赞数
分类专栏： Java基础知识 文章标签： java jvm 算法
于 2023-01-12 23:04:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73651896/article/details/128660180
版权

JVM常量池主要包含四个常量池，分别是：Class文件常量池、运行时常量池、全局字符串常量池、以及基本类型包装类对象常量池。
在这里插入图片描述

一、class文件常量池

为了更加容易的理解本文所说的，我们先写一个程序来分析：

class FinalTest01{
    private int value = 1;
    public String s = "abc";
    public final static int b = 10086;

    public void setValue(int v){
        final int temp = 10010;
        this.value = temp + v;
    }

    public int getValue(){
        return value;
    }
}

javac编译之后，用javap -v命令打开，可以看到：

Classfile /Users/luliang/IdeaProjects/javase/chapter_01/src/FinalTest01.class
  Last modified 2023年1月12日; size 468 bytes
  SHA-256 checksum a317ddafd920cd0e2ce70319c5b7a884624e9bdfb9aebf752c3a2379b4aa7594
  Compiled from "FinalTest01.java"
class FinalTest01
  minor version: 0
  major version: 60
  flags: (0x0020) ACC_SUPER
  this_class: #8                          // FinalTest01
  super_class: #2                         // java/lang/Object
  interfaces: 0, fields: 3, methods: 3, attributes: 1
Constant pool:
   #1 = Methodref          #2.#3          // java/lang/Object."<init>":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Fieldref           #8.#9          // FinalTest01.value:I
   #8 = Class              #10            // FinalTest01
   #9 = NameAndType        #11:#12        // value:I
  #10 = Utf8               FinalTest01
  #11 = Utf8               value
  #12 = Utf8               I
  #13 = String             #14            // abc
  #14 = Utf8               abc
  #15 = Fieldref           #8.#16         // FinalTest01.s:Ljava/lang/String;
  #16 = NameAndType        #17:#18        // s:Ljava/lang/String;
  #17 = Utf8               s
  #18 = Utf8               Ljava/lang/String;
  #19 = Utf8               b
  #20 = Utf8               ConstantValue
  #21 = Integer            10086
  #22 = Utf8               Code
  #23 = Utf8               LineNumberTable
  #24 = Utf8               setValue
  #25 = Utf8               (I)V
  #26 = Utf8               getValue
  #27 = Utf8               ()I
  #28 = Utf8               SourceFile
  #29 = Utf8               FinalTest01.java
					...(不展示字节码)

（一）class 文件组成

任何一个class文件都对应着唯一一个类或接口的定义信息，但反过来说，类或接口并不一定都得定义在文件里（譬如类或接口也可以通过类加载器直接生成）。将任意一个有效的类或接口所应当满足的格式称为“class文件格式”，实际上它并不一定以磁盘文件的形式存在。“class文件”应当是一串二进制的字节流，无论以何种形式存在。接下来的分析都是基于JDK8环境，包括代码和具体的格式。
在这里插入图片描述

1、魔幻数

总共4字节，固定为0xCAFEBABE。class文件的第一个u4结构存储的就是魔数，魔数的唯一作用就是供虚拟机辨别是否是可执行的class文件，并不是只有class文件才有魔数。常见的后缀为jpg、jpeg、png、gif、zip、jar等等这些文件都是有魔数的。比如，我们借助 VScode 插件Hex Editor可以打开字节码文件看看：
在这里插入图片描述
它的魔数确实为CA FE BA BE。我们再看看png 的魔数：
在这里插入图片描述
它的魔数为89 50 4E 47，确实不一样。关于魔幻数，不再赘述。

2、版本号

总共4字节，具体格式为，次版本号（2字节），主版本号（2字节）。本例子中，主版本号为0，次版本号为 60（0x3C）。
在这里插入图片描述

3、常量池

Java代码在进行Javac编译的时候，并不像C和C++那样有“连接”这一步骤，而是在虚拟机加载Class文件的时候进行动态连接。也就是说，在Class文件中不会保存各个方法、字段的最终内存布局信息，因此这些字段、方法的符号引用不经过运行期转换的话无法得到真正的内存入口地址，也就无法直接被虚拟机使用。当虚拟机运行时，需要从常量池获得对应的符号引用，再在类创建时或运行时解析、翻译到具体的内存地址之中。————《深入理解 Java 虚拟机》

上面揭示了为什么 JVM为什么会需要一个 class 文件以及class常量池的作用。事实上，class 文件是用来保存常量的一个中间媒介场所。在 JVM 运行时，需要把常量池中的常量加载到内存中，即从 class 常量池加载到运行时常量池中，方便在运行期间使用其中的常量和各种信息。
class 文件常量池是静态的，而运行时常量池是动态的，它可以不断地变化。

（1）常量池中存放的内容

常量池的容量计数器与其它不同，该计数器是从1开始真正计数的代表的是各个常量的索引，0不指向任何表，而是代表“不引用任何一个常量池中项目”的含义，下图看下常量池的数量是0x1E，代表十进制的30，则表示常量池中有30-1=29个表结构数据。
在这里插入图片描述
我们看看是不是有 29 个：

Classfile /Users/luliang/IdeaProjects/javase/chapter_01/src/FinalTest01.class
  Last modified 2023年1月12日; size 468 bytes
  SHA-256 checksum a317ddafd920cd0e2ce70319c5b7a884624e9bdfb9aebf752c3a2379b4aa7594
  Compiled from "FinalTest01.java"
class FinalTest01
  minor version: 0
  major version: 60
  flags: (0x0020) ACC_SUPER
  this_class: #8                          // FinalTest01
  super_class: #2                         // java/lang/Object
  interfaces: 0, fields: 3, methods: 3, attributes: 1
Constant pool:
   #1 = Methodref          #2.#3          // java/lang/Object."<init>":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Fieldref           #8.#9          // FinalTest01.value:I
   #8 = Class              #10            // FinalTest01
   #9 = NameAndType        #11:#12        // value:I
  #10 = Utf8               FinalTest01
  #11 = Utf8               value
  #12 = Utf8               I
  #13 = String             #14            // abc
  #14 = Utf8               abc
  #15 = Fieldref           #8.#16         // FinalTest01.s:Ljava/lang/String;
  #16 = NameAndType        #17:#18        // s:Ljava/lang/String;
  #17 = Utf8               s
  #18 = Utf8               Ljava/lang/String;
  #19 = Utf8               b
  #20 = Utf8               ConstantValue
  #21 = Integer            10086
  #22 = Utf8               Code
  #23 = Utf8               LineNumberTable
  #24 = Utf8               setValue
  #25 = Utf8               (I)V
  #26 = Utf8               getValue
  #27 = Utf8               ()I
  #28 = Utf8               SourceFile
  #29 = Utf8               FinalTest01.java

果然可以清晰看出总共是有29个常量（表）存储在常量池中。

先解释下上面常量池表的结构，第一列是索引号，也是存储的序号，第二列Methodref、String、Fieldref存储的则是表的类型，第三列存储的则是当前表存储的信息，第四列双斜杠后表示当前结构存储的具体的值起到说明的作用相当于注释，从上面的图片我们不仅可以看到常量池中有29项常量表。

常量池中有哪些表结构？
常量池中总共有17种表结构（截止JDK13），用以存储类中的字面量与符号引用，这些信息在虚拟机解析时会根据索引号找到具体值被加载进虚拟机中，这17种表结构涵盖了所有的java信息，所有的表如下所示：
在这里插入图片描述
因为每一种表结构的存储结构都不相同，因此我们只需要关键性的记住几种即可。
下面我们来具体分析。

什么是常量？一般的理解就是 : 用final修饰的变量是常量 ，以及在编译时期定义好的字符串。但是这种说法是不严谨的，准确来说 ： 常量是final修饰的成员变量（实例变量）和静态变量（静态变量也只能是用static修饰的成员变量）。而用final修饰的局部变量（方法内）并不是常量，而是不可变量，它存储在栈中。

我们只来分析它的常量池部分，既然是常量池，那么其中存放的肯定是常量，那么什么是“常量”呢？ class文件常量池主要存放两大常量：字面量和符号引用。

  • 字面量： 字面量接近java语言层面的常量概念，主要包括：文本字符串，也就是我们经常申明的： public String s = “abc”;中的"abc"：
  #11 = Utf8               value
  #12 = Utf8               I
  #13 = String             #14            // abc
  #14 = Utf8               abc
  • 用final修饰的成员变量，包括静态变量、实例变量和局部变量，就是我们声明的：public final static int b = 10086：
  #19 = Utf8               b
  #20 = Utf8               ConstantValue
  #21 = Integer            10086

而对于基本类型数据(甚至是方法中的局部变量)，也就是上面的private int value = 1;常量池中只保留了他的的字段描述符I和字段的名称value，他们的字面量不会存在于常量池：

  #11 = Utf8               value
  #12 = Utf8               I
  • 类和接口的全限定名，也就是java/lang/String;这样，将类名中原来的".“替换为”/"得到的，主要用于在运行时解析得到类的直接引用，像这样：
   #8 = Class              #10            // FinalTest01
   #10 = Utf8               FinalTest01
  • 字段的名称和描述符，字段也就是类或者接口中声明的变量，包括类级别变量和实例级的变量：
 #7 = Fieldref           #8.#9          // FinalTest01.value:I
   #8 = Class              #10            // FinalTest01
   #9 = NameAndType        #11:#12        // value:I
  #10 = Utf8               FinalTest01
  #11 = Utf8               value
  #12 = Utf8               I
  • 方法中的名称和描述符，也即参数类型+返回值：
 #23 = Utf8               LineNumberTable
  #24 = Utf8               setValue
  #25 = Utf8               (I)V
  #26 = Utf8               getValue
  #27 = Utf8               ()I

可以看到，在常量池中，并没有找到final int temp = 10010;。

4、访问标志

长度：2字节

用于识别类或接口的访问信息， 包括是否为类，是否public等：

{
  public java.lang.String s;
    descriptor: Ljava/lang/String;
    flags: (0x0001) ACC_PUBLIC

  public static final int b;
    descriptor: I
    flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL
    ConstantValue: int 10086

  FinalTest01();
    descriptor: ()V
    flags: (0x0000)
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: iconst_1
         6: putfield      #7                  // Field value:I
         9: aload_0
        10: ldc           #13                 // String abc
        12: putfield      #15                 // Field s:Ljava/lang/String;
        15: return
      LineNumberTable:
        line 1: 0
        line 2: 4
        line 3: 9

  public void setValue(int);
    descriptor: (I)V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=3, locals=2, args_size=2
         0: aload_0
         1: sipush        10010
         4: iload_1
         5: iadd
         6: putfield      #7                  // Field value:I
         9: return
      LineNumberTable:
        line 8: 0
        line 9: 9

  public int getValue();
    descriptor: ()I
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: getfield      #7                  // Field value:I
         4: ireturn
      LineNumberTable:
        line 12: 0
}
SourceFile: "FinalTest01.java"

可以看到各种标志位，比如：

flags: (0x0001) ACC_PUBLIC
flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL
5、类索引、父类索引、接口索引集合

这一项存储的信息主要就是确定当前类的类全限定名、父类全限定名、实现的接口的全限定名。这里的类全限定名、父类全限定名、接口全限定名引用的都是常量池中的信息。类索引、父类索引都是各使用一个u2类型的数据存储，Java支持多实现所以接口索引集合使用多个u2类型的数据进行存储。

6、字段表集合

集合是相同数据结构的无符号数或者表多个汇集在一起，加上前置的容量计数器来构成的。字段表集合结构自然也是这样的是由一个容量计数器加上多个字段表构成的。

public static final int b;
    descriptor: I
    flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL
    ConstantValue: int 10086
7、方法表集合

方法表集由一个容量计数器和多个方法表以及属性表集合构成。一个方法表也是有三个部分（与字段表相同）访问标志、方法名称索引、方法描述符索引三项。与字段表基本一致，不一致的地方是每个方发表都会有自己的属性表集合，因为方法的代码会存储的code这个属性表中（很少有没有代码的方法）。

public void setValue(int);
    descriptor: (I)V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=3, locals=2, args_size=2
         0: aload_0
         1: sipush        10010
         4: iload_1
         5: iadd
         6: putfield      #7                  // Field value:I
         9: return
      LineNumberTable:
        line 8: 0
        line 9: 0
8、属性表集合

属性表集合是class文件结构里要介绍的最后一项，属性表集合并不会单独存在，会和字段表、方发表配合使用，作为这些表的补充存在。常见的方法编译后的代码也会存在code属性表中的，方法中定义的异常是存在Exceptions表中的。

二、运行时常量池

我们知道，JVM在执行某个类的时候，要经过加载、链接（验证、准备、解析）、初始化，在第一步加载的时候需要完成：

  • 获取字节流：通过一个类的全限定名来获取此类的二进制字节流
  • 进行转化：将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
  • 创建类对象：在内存中生成一个类对象，代表加载的这个类，这个对象是java.lang.Class，它作为方法区这个类的各种数据访问的入口。

将class字节流代表的静态存储结构转化为方法区的运行时数据结构，其中就包含了class文件常量池进入运行时常量池的过程。这和数据从辅存进入内存有些相似，但又有不同。不同的类共用一个运行时常量池，同时在进入运行时常量池的过程中，多个class文件中常量池相同的字符串，多个class文件中常量池中相同的字符串只会存在一份在运行时常量池，这本质上是一种优化，主要解决内存过大的问题。

运行时常量池的作用是存储java class文件常量池中的符号信息，运行时常量池中保存着一些class文件中描述的符号引用，同时在类的解析阶段还会将这些符号引用翻译出直接引用（直接指向实例对象的指针，内存地址），翻译出来的直接引用也是存储在运行时常量池中。

运行时常量池相对于class文件常量池的另外一个特性是具备动态性，java语言并不要求常量一定只有编译器才产生，也就是并非预置入class文件中常量池的内容才能进入方法区运行时常量池，运行期间也可能将新的常量放入池中。在运行时可以通过代码生成常量并将其放入运行时常量池中，这种特性被用的最多的就是String.intern()。

三、全局字符串常量池

（一）Java中创建字符串对象的两种方式

String s0 = "helloworld!";
String s1 = new String("helloworld!");

第一种方式声明的字面量"helloworld"是在编译期就已经确定，它会直接进入class文件常量池中；当运行期间在全局字符串常量池中会保存它的一个引用.实际上最终还是要在堆上创建一个”helloworld”对象。

第二种方式方式使用了new String()，调用了String类的构造函数。new指令是创建一个类的实例对象并完成加载初始化的，因此这个字符串对象是在运行期才能确定的，创建的字符串对象是在堆内存上。

因此，s0 和 s1不是一个东西，运行：System.out.println(s0 == s1)的结果肯定是 false，它们的地址并不一样。

（二）Java 方法区运行时内存

对于JDK7，字符串常量池和静态变量被从方法区拿到了堆中，运行时常量池以及其它的信息还在方法区, 也就是hotspot中的永久代。
在这里插入图片描述
但对于 JDK8，hotspot移除了永久代，用元空间(Metaspace)取而代之, 这时候字符串常量池还在堆，运行时常量池还在方法区，只不过方法区的实现从永久代变成了元空间(Metaspace)，也就是内存中，这大大释放了虚拟机内存的空间，提高了性能。
在这里插入图片描述

四、JAVA 基本类型的封装类及对应常量池

Java中基本类型的包装类的大部分都实现了常量池技术，这些类是Byte,Short,Integer,Long,Character,Boolean另外两种浮点数类型的包装类则没有实现。另外上面这5种整型的包装类也只是在对应值小于等于127时才可使用对象池，也即对象不负责创建和管理大于127的这些类的对象。

public class StringConstantPool{

    public static void main(String[] args){
        //5种整形的包装类Byte,Short,Integer,Long,Character的对象，
        //在值小于127时可以使用常量池
        Integer i1=127;
        Integer i2=127;
        System.out.println(i1==i2);//输出true

        //值大于127时，不会从常量池中取对象
        Integer i3=128;
        Integer i4=128;
        System.out.println(i3==i4);//输出false
        //Boolean类也实现了常量池技术

        Boolean bool1=true;
        Boolean bool2=true;
        System.out.println(bool1==bool2);//输出true

        //浮点类型的包装类没有实现常量池技术
        Double d1=1.0;
        Double d2=1.0;
        System.out.println(d1==d2); //输出false

    }
}

本文思维导图：
在这里插入图片描述
全文完，感谢你的阅读。

参考：
https://cloud.tencent.com/developer/article/1690589
https://juejin.cn/post/6844903732757397517
https://developer.aliyun.com/article/1130700
https://www.jianshu.com/p/d8492e748c57
https://cloud.tencent.com/developer/article/1450501
https://blog.csdn.net/AlbenXie/article/details/88542111

瑜陀
关注
专栏目录
JAVA8常量池监控_深入探索Java常量池
weixin_42405592的博客
02-27 192
Java的常量池通常分为两种：静态常量池和运行时常量池静态常量池：class文件中的常量池，class文件中的常量池包括了字符串(数字)字面值，类和方法的信息，占用了class文件的大部分空间。运行时常量池：JVM在完成加载类之后将class文件中常量池载入到内存中，并保存在方法区中。平时我们所讲的常量池就是指方法区中的运行时常量池。其相对于CLass文件常量池的另外一个重要特征是具备动态性，Ja...
java常量池_JAVA常量池
weixin_33167915的博客
02-21 84
java常量池是一个经久不衰的话题，也是面试官的最爱，题目花样百出。理论jvm虚拟内存分布：** 程序计数器是jvm执行程序的流水线，存放一些跳转指令，这个太高深，小菜不懂。** 本地方法栈是jvm调用操作系统方法所使用的栈。** 虚拟机栈是jvm执行java代码所使用的栈。** 方法区存放了一些常量、静态变量、类信息等，可以理解成class文件在内存中的存放位置。...
java常量池与地址_java常量池
weixin_39576127的博客
02-25 315
首先说明一点，在java 中，直接使用==操作符，比较的是两个字符串的引用地址，并不是比较内容，比较内容请用String.equals()。s1 == s2这个非常好理解，s1、s2在赋值时，均使用的字符串字面量，说白话点，就是直接把字符串写死，在编译期间，这种字面量会直接放入class文件的常量池中，从而实现复用，载入运行时常量池后，s1、s2指向的是同一个内存地址，所以相等。s1 == s3这...
java常量池_触摸java常量池
weixin_33734921的博客
02-16 58
转：http://www.cnblogs.com/iyangyuan/p/4631696.htmljava常量池是一个经久不衰的话题，也是面试官的最爱，题目花样百出，小菜早就对常量池有所耳闻，这次好好总结一下。理论小菜先拙劣的表达一下jvm虚拟内存分布：程序计数器是jvm执行程序的流水线，存放一些跳转指令，这个太高深，小菜不懂。本地方法栈是jvm调用操作系统方法所使用的栈。虚拟机栈是jvm执行ja...
java常量池的理解_Java常量池的大概理解
weixin_28809701的博客
02-24 113
转载自：http://www.cnblogs.com/iyangyuan/p/4631696.html理论小菜先拙劣的表达一下jvm虚拟内存分布：程序计数器是jvm执行程序的流水线，存放一些跳转指令，这个太高深，小菜不懂。本地方法栈是jvm调用操作系统方法所使用的栈。虚拟机栈是jvm执行java代码所使用的栈。方法区存放了一些常量、静态变量、类信息等，可以理解成class文件在内存中的存放位置。虚...
java静态池_java 常量池静态变量详解
weixin_42363874的博客
02-17 1429
Java中的常量池，实际上分为两种形态：静态常量池和运行时常量池。所谓静态常量池，即*.class文件中的常量池，class文件中的常量池不仅仅包含字符串(数字)字面量，还包含类、方法的信息，占用class文件绝大部分空间。而运行时常量池，则是jvm虚拟机在完成类装载操作后，将class文件中的常量池载入到内存中，并保存在方法区中，我们常说的常量池，就是指方法区中的运行时常量池。接下来我们引用一些...
Java常量池的大概理解
HD243608836的博客
04-16 253
触摸java常量池     java常量池是一个经久不衰的话题，也是面试官的最爱，题目花样百出，小菜早就对常量池有所耳闻，这次好好总结一下。理论          小菜先拙劣的表达一下jvm虚拟内存分布：      程序计数器是jvm执行程序的流水线，存放一些跳转指令，这个太高深，小菜不懂。     本地方法栈是jvm调用操作系统方法所使用的栈。     虚拟机栈是jvm执行java代码所使用的栈...
java高级——String字符串探索（在jvm底层中如何实现，常量池中怎么查看）
蓝桉
05-21 914
## 4. String类常用的方法 1. endsWith：判断字符串是否以指定的后缀结束 2. startsWith，判断字符串是否以指定的前缀开始 3. `equals`，字符串相等比较，不忽略大小写 4. `equalsIgnoreCase`，字符串相等比较，忽略大小写 5. `indexOf`，取得指定字符在字符串的位置 6. lastIndexOf，返回最后一次字符串出现的位置 7. length，取得字符串的长度 8. `replaceAll`，替换字符串中指定的内容，注意赋值原字符串 9.
令人抓狂的Java常量池探索
JKerving的博客
08-20 959
Java的常量池通常分为两种：静态常量池和运行时常量池 静态常量池：class文件中的常量池，class文件中的常量池包括了字符串(数字)字面值，类和方法的信息，占用了class文件的大部分空间。 运行时常量池：JVM在完成加载类之后将class文件中常量池载入到内存中，并保存在方法区中。平时我们所讲的常量池就是指方法区中的运行时常量池。其相对于CLass文件常量池的另外一个重要特征是具备动态性
深入探索Java常量池
08-28
深入探索Java常量池 Java常量池是Java虚拟机（JVM）中一个非常重要的概念，它主要分为两种：静态常量池和运行时常量池。静态常量池是class文件中的常量池，包括字符串（数字）字面值、类和方法的信息，占用了class...
JVM-7.JVM调优实战及常量池详解
weixin_42287045的博客
10-21 100
1.阿里巴巴Arthas调优工具详解 2.GC日志详解与调优分析 3.Class常量池与运行时常量池详解 4.字符串常量池与基本类型常量池详解
42、探索Go语言魅力：常量应用与最佳实践
silenceallat的博客
06-22 986
本文深入探讨了Go语言中的常量概念，阐释了常量在编程中的重要作用，如数学常数、配置参数、枚举标识符和国际化字符串等。通过具体案例，我们展示了如何在Go中声明和使用常量，以及常量的优势和最佳实践。常量使得代码的意图更加明确，易于维护和重用，同时能提高程序的执行效率。通过本文的介绍，读者可以更好地理解常量的使用场景，并在实际开发中充分发挥常量的优势。
android实战项目实例，android开发艺术探索第二版pdf
2401_84407887的博客
04-21 765
面试题集可以帮助你查漏补缺，有方向有针对性的学习，为之后进大厂做准备。但是如果你仅仅是看一遍，而不去学习和深究。那么这份面试题对你的帮助会很有限。最终还是要靠资深技术水平说话。网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。建议先制定学习计划，根据学习计划把知识点关联起来，形成一个系统化的知识体系。学习方向很容易规划，但是如果只通过碎片化的学习，对自己的提升是很慢的。
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 422
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 529
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 793
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1246
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 327
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
探索Java虚拟机：深入解析第二版
3. **方法区**：也被称为非堆或永久代，它存储了类的元数据，如类的常量池、字段信息、方法信息等。在现代JVM中，这部分功能通常由元空间（Metaspace）取代，以减少对内存的限制。 4. **执行引擎**：这是JVM的核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值