java常量池是什么？Java运行时常量池是什么
大家好，今天给各位分享java常量池是什么的一些知识，其中也会对Java运行时常量池是什么进行解释，文章篇幅可能偏长，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在就马上开始吧！
什么是JVM 运行时常量池
运行时常量池 vs常量池
要弄清楚方法区，需要理解清楚ClassFile，因为加载内的信息都在方法区。
要弄清楚方法区的运行时常量池，需要理解清楚ClassFile中的常量池。
一个Java源文件中的类、接口，编译后产生一个字节码文件。而Java中的字节码需要数据支持，通常这种数据会很大以至于不能直接存在字节码文件，换另一种方式，可以存在常量池，这个字节码包含了指向常量池的引用。在动态链接的时候会用到运行时常量池。
栈帧
[图片上传失败...(image-b8ec8b-1600702650468)]
动态链接
Javad方法区究竟存了什么？？？
Java运行时常量池是什么
在class文件中，“常量池”是最复杂也最值得关注的内容。
Java是一种动态连接的语言，常量池的作用非常重要，常量池中除了包含代码中所定义的各种基本类型（如int、long等等）和对象型（如String及数组）的常量值还，还包含一些以文本形式出现的符号引用，比如：
类和接口的全限定名；
字段的名称和描述符；
方法和名称和描述符。
在C语言中，如果一个程序要调用其它库中的函数，在连接时，该函数在库中的位置（即相对于库文件开头的偏移量）会被写在程序中，在运行时，直接去这个地址调用函数；
而在Java语言中不是这样，一切都是动态的。编译时，如果发现对其它类方法的调用或者对其它类字段的引用的话，记录进class文件中的，只能是一个文本形式的符号引用，在连接过程中，虚拟机根据这个文本信息去查找对应的方法或字段。
所以，与Java语言中的所谓“常量”不同，class文件中的“常量”内容很非富，这些常量集中在class中的一个区域存放，一个紧接着一个，这里就称为“常量池”。
java中的常量池技术，是为了方便快捷地创建某些对象而出现的，当需要一个对象时，就可以从池中取一个出来（如果池中没有则创建一个），则在需要重复重复创建相等变量时节省了很多时间。常量池其实也就是一个内存空间，不同于使用new关键字创建的对象所在的堆空间。本文只从java使用者的角度来探讨java常量池技术，并不涉及常量池的原理及实现方法。个人认为，如果是真的专注java,就必须对这些细节方面有一定的了解。但知道它的原理和具体的实现方法则不是必须的。
常量池中对象和堆中的对象
[java] view plain copy
public class Test{
Integer i1=new Integer(1);
Integer i2=new Integer(1);
//i1,i2分别位于堆中不同的内存空间
System.out.println(i1==i2);//输出false
Integer i3=1;
Integer i4=1;
//i3,i4指向常量池中同一个内存空间
System.out.println(i3==i4);//输出true
//很显然，i1,i3位于不同的内存空间
System.out.println(i1==i3);//输出false
}
8种基本类型的包装类和对象池
java中基本类型的包装类的大部分都实现了常量池技术，这些类是Byte,Short,Integer,Long,Character,Boolean,另外两种浮点数类型的包装类则没有实现。另外Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127时才可使用对象池，也即对象不负责创建和管理大于127的这些类的对象。以下是一些对应的测试代码：
[java] view plain copy
public class Test{
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
}
}
String也实现了常量池技术
String类也是java中用得多的类，同样为了创建String对象的方便，也实现了常量池的技术,测试代码如下:
[java] view plain copy
public class Test{
public static void main(String[] args){
//s1,s2分别位于堆中不同空间
String s1=new String("hello");
String s2=new String("hello");
System.out.println(s1==s2)//输出false
//s3,s4位于池中同一空间
String s3="hello";
String s4="hello";
System.out.println(s3==s4);//输出true
}
}
最后
细节决定成败，写代码更是如此。
在JDK5.0之前是不允许直接将基本数据类型的数据直接赋值给其对应地包装类的，如：Integer i= 5;
但是在JDK5.0中支持这种写法，因为编译器会自动将上面的代码转换成如下代码：Integer i=Integer.valueOf(5);
这就是Java的装箱.JDK5.0也提供了自动拆箱. Integer i=5; int j= i;
Integer的封装：
[java] view plain copy
public static Integer valueOf(int i){
final int offset= 128;
if(i>=-128&& i<= 127){// must cache
return IntegerCache.cache[i+ offset];
}
return new Integer(i);
}
private static class IntegerCache{
private IntegerCache(){}
static final Integer cache[]= new Integer[-(-128)+ 127+ 1];
static{
for(int i= 0; i< cache.length; i++)
cache[i]= new Integer(i- 128);
}
}
由于cache[]在IntegerCache类中是静态数组，也就是只需要初始化一次，即static｛......｝部分，所以，如果Integer对象初始化时是-128~127的范围，就不需要再重新定义申请空间，都是同一个对象---在IntegerCache.cache中，这样可以在一定程度上提高效率。
JAVA常量池中存储的常量是什么
我当初也存在这样一个疑问，下面我把当初所搜集的一些资料以及自己的理解贴出来给你看看(比较多，需要耐心点看，呵呵)：
理解Java常量池
JVM运行时数据区的内存模型由五部分组成：
【1】方法区
【2】堆
【3】JAVA栈
【4】PC寄存器
【5】本地方法栈
对于String s="haha",它的虚拟机指令：
0: ldc#16;//String haha
2: astore_1
3: return
对于上面虚拟机指令，其各自的指令流程在《深入JAVA虚拟机》这样描述到(结合上面实例)：
ldc指令格式：ldc,index
ldc指令过程：
要执行ldc指令，JVM首先查找index所指定的常量池入口，在index指向的常量池入口，JVM将会查找CONSTANT_Integer_info，CONSTANT_Float_info和CONSTANT_String_info入口。如果还没有这些入口，JVM会解析它们。而对于上面的hahaJVM会找到CONSTANT_String_info入口，同时，将把指向被拘留String对象（由解析该入口的进程产生）的引用压入操作数栈。
astore_1指令格式：astore_1
astore_1指令过程：
要执行astore_1指令，JVM从操作数栈顶部弹出一个引用类型或者returnAddress类型值，然后将该值存入由索引1指定的局部变量中,即将引用类型或者returnAddress类型值存入局部变量1。
return指令的过程：
从方法中返回，返回值为void。
谈一下我个人理解：
从上面的ldc指令的执行过程可以得出：s的值是来自被拘留String对象（由解析该入口的进程产生）的引用，即可以理解为是从被拘留String对象的引用复制而来的，故我个人的理解是s的值是存在栈当中。上面是对于s值得分析，接着是对于"haha"值的分析,我们知道，对于String s="haha"其中"haha"值在JAVA程序编译期就确定下来了的。简单一点说，就是haha的值在程序编译成class文件后，就在class文件中生成了（大家可以用UE编辑器或其它文本编辑工具在打开class文件后的字节码文件中看到这个haha值）。执行JAVA程序的过程中，第一步是class文件生成，然后被JVM装载到内存执行。那么JVM装载这个class到内存中，其中的haha这个值，在内存中是怎么为其开辟空间并存储在哪个区域中呢？
说到这里，我们不妨先来了解一下JVM常量池这个结构，《深入JAVA虚拟机》书中有这样的
常量池
虚拟机必须为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集和，包括直接常量（string,integer和floating point常量）和对其他类型，字段和方法的符号引用。对于String常量，它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的，对于String类型，有一张固定长度的CONSTANT_String_info表用来存储文字字符串值，注意：该表只存储文字字符串值，不存储符号引用。说到这里，对常量池中的字符串值的存储位置应该有一个比较明了的理解了。
在介绍完JVM常量池的概念后，接着谈开始提到的"haha"的值的内存分布的位置。对于haha的值，实际上是在class文件被JVM装载到内存当中并被引擎在解析ldc指令并执行ldc指令之前，JVM就已经为haha这个字符串在常量池的CONSTANT_String_info表中分配了空间来存储haha这个值。既然haha这个字符串常量存储在常量池中，根据《深入JAVA虚拟机》书中常量池是属于类型信息的一部分，类型信息也就是每一个被转载的类型，这个类型反映到JVM内存模型中是对应存在于JVM内存模型的方法区中，也就是这个类型信息中的常量池概念是存在于在方法区中，而方法区是在JVM内存模型中的堆中由JVM来分配的。所以，haha的值是应该是存在堆空间中的。
而对于String s= new String("haha"),它的JVM指令：
0: new#16;//class String
3: dup
4: ldc#18;//String haha
6: invokespecial#20;//Method java/lang/String."":(Ljava/lang/String;)V
9: astore_1
10: return
对于上面虚拟机指令，其各自的指令流程在《深入JAVA虚拟机》这样描述到(结合上面实例)：
new指令格式：new indexbyte1,indexbyte2
new指令过程：
要执行new指令，Jvm通过计算(indextype1<<8)|indextype2生成一个指向常量池的无符号16位索引。然后JVM根据计算出的索引查找常量池入口。该索引所指向的常量池入口必须为CONSTANT_Class_info。如果该入口尚不存在，那么JVM将解析这个常量池入口，该入口类型必须是类。JVM从堆中为新对象映像分配足够大的空间，并将对象的实例变量设为默认值。最后JVM将指向新对象的引用objectref压入操作数栈。
dup指令格式：dup
dup指令过程：
要执行dup指令，JVM复制了操作数栈顶部一个字长的内容，然后再将复制内容压入栈。本指令能够从操作数栈顶部复制任何单位字长的值。但绝对不要使用它来复制操作数栈顶部任何两个字长(long型或double型)中的一个字长。上面例中，即复制引用objectref，这时在操作数栈存在2个引用。
ldc指令格式：ldc,index
ldc指令过程：
要执行ldc指令，JVM首先查找index所指定的常量池入口，在index指向的常量池入口，JVM将会查找CONSTANT_Integer_info，CONSTANT_Float_info和CONSTANT_String_info入口。如果还没有这些入口，JVM会解析它们。而对于上面的haha,JVM会找到CONSTANT_String_info入口，同时，将把指向被拘留String对象（由解析该入口的进程产生）的引用压入操作数栈。
invokespecial指令格式：invokespecial,indextype1,indextype2
invokespecial指令过程：对于该类而言，该指令是用来进行实例初始化方法的调用。鉴于该指令篇幅，具体可以查阅《深入JAVA虚拟机》中描述。上面例子中，即通过其中一个引用调用String类的构造器，初始化对象实例，让另一个相同的引用指向这个被初始化的对象实例，然后前一个引用弹出操作数栈。
astore_1指令格式：astore_1
astore_1指令过程：
要执行astore_1指令，JVM从操作数栈顶部弹出一个引用类型或者returnAddress类型值，然后将该值存入由索引1指定的局部变量中,即将引用类型或者returnAddress类型值存入局部变量1。
return指令的过程:
从方法中返回，返回值为void。
要执行astore_1指令，JVM从操作数栈顶部弹出一个引用类型或者returnAddress类型值，然后将该值存入由索引1指定的局部变量中,即将引用类型或者returnAddress类型值存入局部变量1。
通过上面6个指令，可以看出，String s= new String("haha");中的haha存储在堆空间中，而s则是在操作数栈中。
上面是对s和haha值的内存情况的分析和理解；那对于String s= new String("haha");语句,到底创建了几个对象呢?
我的理解：这里"haha"本身就是常量池中的一个对象，而在运行时执行new String()时，将常量池中的对象复制一份放到堆中，并且把堆中的这个对象的引用交给s持有。所以这条语句就创建了2个String对象。
下面是一些String相关的常见问题：
String中的final用法和理解
final StringBuffer a= new StringBuffer("111");
final StringBuffer b= new StringBuffer("222");
a=b;//此句编译不通过
final StringBuffer a= new StringBuffer("111");
a.append("222");//编译通过
可见，final只对引用的"值"(即内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。
String常量池问题的几个例子
下面是几个常见例子的比较分析和理解：
[1]
String a="a1";
String b="a"+ 1;
System.out.println((a== b));//result= true
String a="atrue";
String b="a"+"true";
System.out.println((a== b));//result= true
String a="a3.4";
String b="a"+ 3.4;
System.out.println((a== b));//result= true
分析：JVM对于字符串常量的"+"号连接，将程序编译期，JVM就将常量字符串的"+"连接优化为连接后的值，拿"a"+ 1来说，经编译器优化后在class中就已经是a1。在编译期其字符串常量的值就确定下来，故上面程序最终的结果都为true。
[2]
String a="ab";
String bb="b";
String b="a"+ bb;
System.out.println((a== b));//result= false
分析：JVM对于字符串引用，由于在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的，即"a"+ bb无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给b。所以上面程序的结果也就为false。
[3]
String a="ab";
final String bb="b";
String b="a"+ bb;
System.out.println((a== b));//result= true
分析：和[3]中唯一不同的是bb字符串加了final修饰，对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。所以此时的"a"+ bb和"a"+"b"效果是一样的。故上面程序的结果为true。
[4]
String a="ab";
final String bb= getBB();
String b="a"+ bb;
System.out.println((a== b));//result= false
private static String getBB(){
return"b";
}
分析：JVM对于字符串引用bb，它的值在编译期无法确定，只有在程序运行期调用方法后，将方法的返回值和"a"来动态连接并分配地址为b，故上面程序的结果为false。
通过上面4个例子可以得出得知：
String s="a"+"b"+"c";
就等价于String s="abc";
String a="a";
String b="b";
String c="c";
String s= a+ b+ c;
这个就不一样了，最终结果等于：
StringBuffer temp= new StringBuffer();
temp.append(a).append(b).append(c);
String s= temp.toString();
由上面的分析结果，可就不难推断出String采用连接运算符（+）效率低下原因分析，形如这样的代码：
public class Test{
public static void main(String args[]){
String s= null;
for(int i= 0; i< 100; i++){
s+="a";
}
}
}
每做一次+就产生个StringBuilder对象，然后append后就扔掉。下次循环再到达时重新产生个StringBuilder对象，然后 append字符串，如此循环直至结束。如果我们直接采用 StringBuilder对象进行 append的话，我们可以节省 N- 1次创建和销毁对象的时间。所以对于在循环中要进行字符串连接的应用，一般都是用StringBuffer或StringBulider对象来进行append操作。
String对象的intern方法理解和分析：
public class Test4{
private static String a="ab";
public static void main(String[] args){
String s1="a";
String s2="b";
String s= s1+ s2;
System.out.println(s== a);//false
System.out.println(s.intern()== a);//true
}
}
这里用到Java里面是一个常量池的问题。对于s1+s2操作，其实是在堆里面重新创建了一个新的对象,s保存的是这个新对象在堆空间的的内容，所以s与a的值是不相等的。而当调用s.intern()方法，却可以返回s在常量池中的地址值，因为a的值存储在常量池中，故s.intern和a的值相等
好了，文章到此结束，希望可以帮助到大家。