JVM常量池和八种基本数据及字符串

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

在Class文件结构中，最头的4个字节用于存储魔数Magic Number，用于确定一个文件是否能被JVM接受，再接着4个字节用于存储版本号，前2个字节存储次版本号，后2个存储主版本号，再接着是用于存放常量的常量池，由于常量的数量是不固定的，所以常量池的入口放置一个U2类型的数据(constant_pool_count)存储常量池容量计数值。常量池主要用于存放两大类常量：字面量(Literal)和符号引用量(Symbolic References)，字面量相当于Java语言层面常量的概念，如文本字符串，声明为final的常量值等，符号引用则属于编译原理方面的概念，包括了如下三种类型的常量：

类和接口的全限定名

字段名称和描述符

方法名称和描述符

Java中八种基本类型的包装类的大部分都实现了常量池技术，它们是Byte、Short、Integer、Long、Character、Boolean，另外两种浮点数类型的包装类(Float、Double)则没有实现。另外Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值在-128到127时才可使用对象池。

看下面代码：

Java代码

/**
* Huisou.com Inc.
* Copyright (c) 2011-2012 All Rights Reserved.
*/
/**
* @description
* @package
* @title Test.java
* @author chenzehe
* @email
* @version
* @updateUser
* @create 2011-12-21 上午11:27:48
* @update 2011-12-21 上午11:27:48
*/
public class Test {
public static void main(String[] args) throws Exception {
Integer a = 127;
Integer b = 127;
Integer c = 128;
Integer d = 128;
System.out.println(a == b);// 输出true
System.out.println(c == d);// 输出false
}
}

使用javap查看生成的字节码：

Java代码

E:\chenzehe\workspace_b2b_3th\test\src>javap -verbose Test
Compiled from "Test.java"
public class Test extends java.lang.Object
SourceFile: "Test.java"
minor version: 0
major version: 50
Constant pool:
const #1 = Method #6.#21; // java/lang/Object."<init>":()V
const #2 = Method #22.#23; // java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
const #3 = Field #24.#25; // java/lang/System.out:Ljava/io/PrintStream;
const #4 = Method #26.#27; // java/io/PrintStream.println:(Z)V
const #5 = class #28; // Test
const #6 = class #29; // java/lang/Object
const #7 = Asciz <init>;
const #8 = Asciz ()V;
const #9 = Asciz Code;
const #10 = Asciz LineNumberTable;
const #11 = Asciz main;
const #12 = Asciz ([Ljava/lang/String;)V;
const #13 = Asciz StackMapTable;
const #14 = class #30; // "[Ljava/lang/String;"
const #15 = class #31; // java/lang/Integer
const #16 = class #32; // java/io/PrintStream
const #17 = Asciz Exceptions;
const #18 = class #33; // java/lang/Exception
const #19 = Asciz SourceFile;
const #20 = Asciz Test.java;
const #21 = NameAndType #7:#8;// "<init>":()V
const #22 = class #31; // java/lang/Integer
const #23 = NameAndType #34:#35;// valueOf:(I)Ljava/lang/Integer;
const #24 = class #36; // java/lang/System
const #25 = NameAndType #37:#38;// out:Ljava/io/PrintStream;
const #26 = class #32; // java/io/PrintStream
const #27 = NameAndType #39:#40;// println:(Z)V
const #28 = Asciz Test;
const #29 = Asciz java/lang/Object;
const #30 = Asciz [Ljava/lang/String;;
const #31 = Asciz java/lang/Integer;
const #32 = Asciz java/io/PrintStream;
const #33 = Asciz java/lang/Exception;
const #34 = Asciz valueOf;
const #35 = Asciz (I)Ljava/lang/Integer;;
const #36 = Asciz java/lang/System;
const #37 = Asciz out;
const #38 = Asciz Ljava/io/PrintStream;;
const #39 = Asciz println;
const #40 = Asciz (Z)V;
{
public Test();
Code:
Stack=1, Locals=1, Args_size=1
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 18: 0
public static void main(java.lang.String[]) throws java.lang.Exception;
Code:
Stack=3, Locals=5, Args_size=1
0: bipush 127
2: invokestatic #2; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
5: astore_1
6: bipush 127
8: invokestatic #2; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
11: astore_2
12: sipush 128
15: invokestatic #2; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
18: astore_3
19: sipush 128
22: invokestatic #2; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
25: astore 4
27: getstatic #3; //Field java/lang/System.out:Ljava/io/PrintStream;
30: aload_1
31: aload_2
32: if_acmpne 39
35: iconst_1
36: goto 40
39: iconst_0
40: invokevirtual #4; //Method java/io/PrintStream.println:(Z)V
43: getstatic #3; //Field java/lang/System.out:Ljava/io/PrintStream;
46: aload_3
47: aload 4
49: if_acmpne 56
52: iconst_1
53: goto 57
56: iconst_0
57: invokevirtual #4; //Method java/io/PrintStream.println:(Z)V
60: return
LineNumberTable:
line 20: 0
line 21: 6
line 22: 12
line 23: 19
line 24: 27
line 25: 43
line 26: 60
StackMapTable: number_of_entries = 4
frame_type = 255 /* full_frame */
offset_delta = 39
locals = [ class "[Ljava/lang/String;", class java/lang/Integer, class java/lang/Integer, class java/lang/Inte
ger, class java/lang/Integer ]
stack = [ class java/io/PrintStream ]
frame_type = 255 /* full_frame */
offset_delta = 0
locals = [ class "[Ljava/lang/String;", class java/lang/Integer, class java/lang/Integer, class java/lang/Inte
ger, class java/lang/Integer ]
stack = [ class java/io/PrintStream, int ]
frame_type = 79 /* same_locals_1_stack_item */
stack = [ class java/io/PrintStream ]
frame_type = 255 /* full_frame */
offset_delta = 0
locals = [ class "[Ljava/lang/String;", class java/lang/Integer, class java/lang/Integer, class java/lang/Inte
ger, class java/lang/Integer ]
stack = [ class java/io/PrintStream, int ]
Exceptions:
throws java.lang.Exception
}

Integer a = 127;对应的指令为：

Java代码

0: bipush 127
2: invokestatic #2; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

Integer c = 128;对应的指令为：

Java代码

12: sipush 128
15: invokestatic #2; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

bipush指令意思是将单字节的常量值(-128~127)推送到栈顶

sipush指令意思是将短型的常量值(-32768~32767)推送到栈顶

invokestatic指令意思是调用静态方法，这里调用的是常量池中#2指向的方法java/lang/Integer.valueOf，查看Integer.valueOf方法：

Java代码

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);
}

IntegerCache代码：

Java代码

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);
}
}

其它封装类如下：

Java代码

//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 s = new String( "xyz" ); 在运行时涉及几个String实例？

两个，一个是字符串字面量"xyz"所对应的、驻留（intern）在一个全局共享的字符串常量池中的实例，另一个是通过new String(String)创建并初始化的、内容与"xyz"相同的实例。

String中的final用法和理解：

final只对引用的"值"(即内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。

Java代码

final StringBuffer a = new StringBuffer("111");
final StringBuffer b = new StringBuffer("222");
a=b;//此句编译不通过
final StringBuffer a = new StringBuffer("111");
a.append("222");//编译通过

Java代码

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。

Java代码

String a = "ab";
String bb = "b";
String b = "a" + bb;
System.out.println((a == b)); //result = false

JVM对于字符串引用，由于在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的，即"a" + bb无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给b。所以上面程序的结果也就为false。

Java代码

String a = "ab";
final String bb = "b";
String b = "a" + bb;
System.out.println((a == b)); //result = true

和上面唯一不同的是bb字符串加了final修饰，对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。所以此时的"a" + bb和"a" + "b"效果是一样的。故上面程序的结果为true。

Java代码

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个例子可以得出得知：

Java代码

String s = "a" + "b" + "c";

就等价于String s = "abc"; int i = 1+2+3;也等价于int i = 6;

Java代码

String a = "a";
String b = "b";
String c = "c";
String s = a + b + c;

这个就不一样了，最终结果等于：

Java代码

StringBuffer temp = new StringBuffer();
temp.append(a).append(b).append(c);
String s = temp.toString();

由上面的分析结果，可就不难推断出String 采用连接运算符（+）效率低下原因分析，形如这样的代码：

Java代码

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()解析

Java语言并不要求常量一定只能在编译期产生，运行时也可能将新的常量放入常量池中，这种特性用的最多的就是String.intern()方法。

String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用。

Java代码

String s0= "xyz";
String s1=new String("xyz");
String s2=new String("xyz");
System.out.println(s0==s1);
s1.intern();
s2=s2.intern(); //把常量池中“pku”的引用赋给s2
System.out.println( s0==s1);
System.out.println( s0==s1.intern() );
System.out.println( s0==s2 );

输出为：
false
false //虽然执行了s1.intern(),但它的返回值没有赋给s1
true //说明s1.intern()返回的是常量池中”pku”的引用
true

有人说，“使用String.intern()方法则可以将一个String类的保存到一个全局String表中，如果具有相同值的Unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中“如果我把他说的这个全局的String 表理解为常量池的话，他的最后一句话，“如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的：

Java代码

String s1=new String("xyz");
String s2=s1.intern();
System.out.println( s1==s1.intern() );
System.out.println( s1+" "+s2 );
System.out.println( s2==s1.intern() );

输出为：
false
xyz xyz
true

JVM常量池和八种基本数据及字符串相关推荐

《性能调优之JVM》❤️04JVM常量池详解之深入理解Class常量池、运行时常量池、字符串常量池、八种基本数据类型的包装类和对象池
JVM常量池详解一.Class常量池 1.1字面量 1.2符号引用二.运行时常量池三.字符串常量池 3.1设计思想 3.2设计原理 3.3字符串常量池位置 3.4三种字符串操作四.八种基本数据 ...
JVM出现OOM的八种原因及解决办法
本文源自转载:JVM出现OOM的八种原因及解决办法目录一.堆溢出 1.1 原因 1.2解决方法二.永久代/元空间溢出 2.1 原因 2.2 解决方法三.GC overhead limit ex ...
JVM常量池最全详解-常量池/运行时常量池/字符串常量池/基本类型常量池，看这一篇就够了
JVM常量池最全详解-常量池/运行时常量池/字符串常量池/基本类型常量池,看这一篇就够了! 常量池详解 1. 字面量和符号引用 1.1 字面量 1.2 符号引用 2. 常量池vs运行时常量池 3. 常 ...
java 更改常量池_JVM中三个常量池（两种常量池）的解析及其随jdk版本的变化
目录常量池静态常量池运行时常量池字符串常量池三个常量池的关系其随jdk版本的变化常量池请注意常量池是线程共享数据区,常量池的内容: 常量池的好处: 常量池是为了避免频繁的创建和销毁对象 ...
（全网最详细最有深度）超过1W字深度剖析JVM常量池
字符串常量池存储在堆内存空间中,创建形式如下图所示. 当使用String a="Hello"这种方式创建字符串对象时,JVM首先会先检查该字符串对象是否存在与字符串常量池中,如果存 ...
详解JVM常量池、Class常量池、运行时常量池、字符串常量池(心血总结)
写在前面:博主是一位普普通通的19届双非软工在读生,平时最大的爱好就是听听歌,逛逛B站.博主很喜欢的一句话花开堪折直须折,莫待无花空折枝:博主的理解是头一次为人,就应该做自己想做的事,做自己不后悔的事 ...
八种基本数据类型变量声明
package com.hisoft.java.Bean;public class Test1 { static int age=12; // String str = new String(&quo ...
JVM常量池和运行时常量池
一.类的二进制字节码包含哪些信息要理解常量池是什么,先看看类的二进制字节码包含哪些信息!!! 常量池类的基本信息(比如:类的访问权限.类的名称.实现了哪些接口) 类的方法定义(包含了虚拟机指令,也 ...
Java 线程池 ThreadPoolExecutor 八种拒绝策略浅析
前言谈到 Java 的线程池最熟悉的莫过于 ExecutorService 接口了,jdk1.5 新增的 java.util.concurrent 包下的这个 api,大大的简化了多线程代码的开发. ...
Java中几种常量池(字符串常量池, Class常量池, 运行时常量池)的区别与联系
简介: 这几天在看Java虚拟机方面的知识时,看到了有几种不同常量池的说法,然后我就去CSDN.博客园等上找资料,里面说的内容真是百花齐放,各自争艳,因此,我好好整理了一下,将我自认为对的理解写下来与 ...

JVM常量池和八种基本数据及字符串

JVM常量池和八种基本数据及字符串相关推荐

最新文章

热门文章