第三篇：各种数据类型的常量池技术

已于 2022-11-30 20:59:36 修改
阅读量606 收藏
点赞数
分类专栏： JavaSE 文章标签： java 前端 算法
于 2020-10-21 20:29:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36963950/article/details/109209176
版权

文章目录

一、前言

Java中常量池大体可以分为：静态常量池，运行时常量池。

class文件常量池：存在于class文件中，如经常使用的javap -verbose中；

运行时常量池：就是在class文件被加载进了内存之后，常量池保存在了方法区中。

通常说的常量池指的是运行时常量池，本文讨论的都是运行时常量池。

二、基本类型常量池

Java中基本类型的常量池技术不是由基本类型实现的，而是由基本类型对应的包装类型实现的。但是因为Java5.0后引入自动装包和自动拆包，所以这一点已经不重要了。

基本类型包装类型常量池技术常量池范围
boolBoolean实现了常量池true/false
charCharacter实现了常量池0~127
byteByte实现了常量池-128~127
shortShort实现了常量池-128~127
intInterger实现了常量池-128~127
longLong实现了常量池-128~127
floatFloat未实现常量池未实现常量池
doubleDouble未实现常量池未实现常量池

2.1 Boolean常量池

代码1——常量池比较 true

package mypackage;
 
public class TestConstantPool {
	public static void main(String[] args) {
		Boolean boolean1 = true;
		Boolean boolean2 = true;
		System.out.println(boolean1 == boolean2);// 打印true 包装类型Boolean实现了常量池技术
		boolean1 = false;
		boolean2 = false;
		System.out.println(boolean1 == boolean2);// true
	}
}

输出：

true
true

代码2——新建对象比较 一定返回false

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
		Boolean boolean1 = new Boolean(true);
		Boolean boolean2 = new Boolean(true);
		System.out.println(boolean1 == boolean2);// false 不同对象指向不同地址
	}
 
}

输出：

false

代码3——基本类型比较（true 栈内存中，数值相等即为true，与常量池无关）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
		boolean _b1=true;
		boolean _b2=true;
		System.out.println(_b1==_b2);//true
	}
 
}

输出：

true

金手指：Boolean/boolean

第一，基本类型仅比较值，全为true;

第二，新建对象比较引用(即内存地址),全为false, 运算符拆箱后变为基本类型，全为true;

第三，常量池（编译时类型为包装类型，运行时类型为基本类型）比较介于两者之间，常量池范围内(true|false)为true,又常量池覆盖Boolean所有范围(true|false),故Boolean常量池均为true。

2.2 字符型（Character）常量池

代码1——常量池比较（涉及常量池：Character在(0 ~ 127)使用常量池技术，返回为true，范围外在堆中新建对象，返回为false）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
		Character _cCharacter = (char) -1;
		Character _cCharacter2 = (char) -1;
		System.out.println(_cCharacter == _cCharacter2);// false
 
		Character _cCharacter3 = (char) 0;
		Character _cCharacter4 = (char) 0;
		System.out.println(_cCharacter3 == _cCharacter4);// true
 
		Character _cCharacter5 = (char) 127;
		Character _cCharacter6 = (char) 127;
		System.out.println(_cCharacter5 == _cCharacter6);// true
 
		Character _cCharacter7 = (char) 128;
		Character _cCharacter8 = (char) 128;
		System.out.println(_cCharacter7 == _cCharacter8);// false
	}
 
}

输出：

false
true
true
false

代码2——新建对象比较（直接比较new对象，一定为false，拆箱比较，一定为true）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
		Character _cCharacter0 = new Character((char) 0);
 
		Character _cCharacter = new Character((char) -1);
		Character _cCharacter2 = new Character((char) -1);
		System.out.println("新建对象后比较: " + (_cCharacter == _cCharacter2));
		System.out.println("自动拆箱后比较: " + (_cCharacter == _cCharacter2 + _cCharacter0));
 
		Character _cCharacter3 = new Character((char) 0);
		Character _cCharacter4 = new Character((char) 0);
		System.out.println("新建对象后比较: " + (_cCharacter3 == _cCharacter4));
		System.out.println("自动拆箱后比较: " + (_cCharacter3 == _cCharacter4 + _cCharacter0));
 
		Character _cCharacter5 = new Character((char) 127);
		Character _cCharacter6 = new Character((char) 127);
		System.out.println("新建对象后比较: " + (_cCharacter5 == _cCharacter6));
		System.out.println("自动拆箱后比较: " + (_cCharacter5 == _cCharacter6 + _cCharacter0));
 
		Character _cCharacter7 = new Character((char) 128);
		Character _cCharacter8 = new Character((char) 128);
		System.out.println("新建对象后比较: " + (_cCharacter7 == _cCharacter8));
		System.out.println("自动拆箱后比较: " + (_cCharacter7 == _cCharacter8 + _cCharacter0));
	}
 
}

输出：

新建对象后比较: false
自动拆箱后比较: true
新建对象后比较: false
自动拆箱后比较: true
新建对象后比较: false
自动拆箱后比较: true
新建对象后比较: false
自动拆箱后比较: true

注意： 当出现运算符的时候，包装类型不可能直接用来运算，所以会进行一次拆箱成为基本数字进行比较，所以变成了两个基本类型之间的比较，仅比较值，则为true。

代码3——基本类型比较（true 栈内存中，数值相等即为true，与常量池无关）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
		char _cCharacter = (char) -1;
		char _cCharacter2 = (char) -1;
		System.out.println(_cCharacter == _cCharacter2);// true
 
		char _cCharacter3 = (char) 0;
		char _cCharacter4 = (char) 0;
		System.out.println(_cCharacter3 == _cCharacter4);// true
 
		char _cCharacter5 = (char) 127;
		char _cCharacter6 = (char) 127;
		System.out.println(_cCharacter5 == _cCharacter6);// true
 
		char _cCharacter7 = (char) 128;
		char _cCharacter8 = (char) 128;
		System.out.println(_cCharacter7 == _cCharacter8);// true
	}
 
}

输出：

true
true
true
true

金手指：Character/char

第一，基本类型仅比较值，全为true;

第二，新建对象比较引用(即内存地址)，全为false, 运算符拆箱后变为基本类型，全为true;

第三，常量池（编译时类型为包装类型，运行时类型为基本类型）比较介于两者之间，常量池范围内(0~127)为true,常量池范围外jvm会重新新建对象，故为false。

2.3 Byte常量池

代码1——常量池比较（-128~127全部为true，byte也不能超过这个范围，所以byte全部为true）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
		// Byte _bByte=(byte) -129;
		// Byte _bByte2=(byte) -129; byte仅一个字节 -128~127 超出范围
 
		Byte _bByte3 = -128;
		Byte _bByte4 = -128;
		System.out.println(_bByte3 == _bByte4);
 
		Byte _bByte5 = 127;
		Byte _bByte6 = 127;
		System.out.println(_bByte5 == _bByte6);
 
		// Byte _bByte7=(byte) 128;
		// Byte _bByte8=(byte) 128; byte仅一个字节 -128~127 超出范围
	}
 
}

输出：

true
true

代码2——新建对象后比较（直接比较new对象，一定为false，拆箱比较，一定为true）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
		Byte _bByte0 = new Byte((byte) 0);
 
		Byte _bByte3 = new Byte((byte) -128);
		Byte _bByte4 = new Byte((byte) -128);
		System.out.println("新建对象后比较: " + (_bByte3 == _bByte4));
		System.out.println("自动拆箱后比较: " + (_bByte3 == _bByte4 + _bByte0));
 
		Byte _bByte5 = new Byte((byte) 127);
		Byte _bByte6 = new Byte((byte) 127);
		System.out.println("新建对象后比较: " + (_bByte5 == _bByte6));
		System.out.println("自动拆箱后比较: " + (_bByte5 == _bByte6 + _bByte0));
 
	}
 
}

输出：

新建对象后比较: false
自动拆箱后比较: true
新建对象后比较: false
自动拆箱后比较: true

注意： 当出现运算符的时候，包装类型不可能直接用来运算，所以会进行一次拆箱成为基本数字进行比较，所以变成了两个基本类型之间的比较，仅比较值，则为true。

代码3——基本类型比较（true 栈内存中，数值相等即为true，与常量池无关）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
 
 
		byte _bByte3 = -128;
		byte _bByte4 = -128;
		System.out.println(_bByte3 == _bByte4);
 
		byte _bByte5 = 127;
		byte _bByte6 = 127;
		System.out.println(_bByte5 == _bByte6);
 
	}
 
}

输出：

true
true

金手指：Byte/byte

第一，基本类型仅比较值，全为true;

第二，新建对象比较引用(即内存地址)，全为false, 运算符拆箱后变为基本类型，全为true;

第三，常量池（编译时类型为包装类型，运行时类型为基本类型）比较介于两者之间，常量池范围内(-128 ~ 127)为true,又常量池覆盖Byte所有范围(-128~127)，故Byte常量池均为true。

2.4 Short常量池

代码1——常量池比较（涉及常量池：Short在(-128 ~ 127)使用常量池技术，返回为true，范围外在堆中新建对象，返回为false）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
		Short _sShort=-129;
		Short _sShort2=-129;
		System.out.println(_sShort==_sShort2);
		
		Short _sShort3=-128;
		Short _sShort4=-128;
		System.out.println(_sShort3==_sShort4);
		
		Short _sShort5=127;
		Short _sShort6=127;
		System.out.println(_sShort5==_sShort6);
		
		Short _sShort7=128;
		Short _sShort8=128;
		System.out.println(_sShort7==_sShort8);
	}
 
}

输出：

false
true
true
false

代码2——新建对象后比较（直接比较new对象，一定为false，与-128 ~ 127范围无关，纯对象比较；拆箱比较，一定为true，与-128 ~ 127范围无关，纯数值比较）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
		Short _sShort0 = new Short((short) 0);
 
		Short _sShort = new Short((short) -129);
		Short _sShort2 = new Short((short) -129);
		System.out.println("新建对象后比较: " + (_sShort == _sShort2));
		System.out.println("自动拆箱后比较: " + (_sShort == _sShort2 + _sShort0));
 
		Short _sShort3 = new Short((short) -128);
		Short _sShort4 = new Short((short) -128);
		System.out.println("新建对象后比较: " + (_sShort3 == _sShort4));
		System.out.println("自动拆箱后比较: " + (_sShort3 == _sShort4 + _sShort0));
 
		Short _sShort5 = new Short((short) 127);
		Short _sShort6 = new Short((short) 127);
		System.out.println("新建对象后比较: " + (_sShort5 == _sShort6));
		System.out.println("自动拆箱后比较: " + (_sShort5 == _sShort6 + _sShort0));
 
		Short _sShort7 = new Short((short) 128);
		Short _sShort8 = new Short((short) 128);
		System.out.println("新建对象后比较: " + (_sShort7 == _sShort8));
		System.out.println("自动拆箱后比较: " + (_sShort7 == _sShort8 + _sShort0));
	}
 
}

输出：

新建对象后比较: false
自动拆箱后比较: true
新建对象后比较: false
自动拆箱后比较: true
新建对象后比较: false
自动拆箱后比较: true
新建对象后比较: false
自动拆箱后比较: true

注意： 当出现运算符的时候，包装类型不可能直接用来运算，所以会进行一次拆箱成为基本数字进行比较，所以变成了两个基本类型之间的比较，仅比较值，则为true。

代码3——基本类型比较（true 栈内存中，数值相等即为true，与常量池无关）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
 
		short _sShort = -129;
		short _sShort2 = -129;
		System.out.println(_sShort == _sShort2);
 
		short _sShort3 = -128;
		short _sShort4 = -128;
		System.out.println(_sShort3 == _sShort4);
 
		short _sShort5 = 127;
		short _sShort6 = 127;
		System.out.println(_sShort5 == _sShort6);
 
		short _sShort7 = 128;
		short _sShort8 = 128;
		System.out.println(_sShort7 == _sShort8);
	}
 
}

输出：

true
true
true
true

金手指：Short/short

第一，基本类型仅比较值，全为true;

第二，新建对象比较引用(即内存地址)，全为false, 运算符拆箱后变为基本类型，全为true;

第三，常量池（编译时类型为包装类型，运行时类型为基本类型）比较介于两者之间，常量池范围内(-128~127)为true,常量池范围外会jvm重新新建对象,故为false。

2.5 Integer常量池

代码1——常量池比较（涉及常量池：Integer在(-128 ~ 127)使用常量池技术，返回为true，范围外在堆中新建对象，返回为false）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
		Integer _iInteger=-129;
		Integer _iInteger2=-129;
		System.out.println(_iInteger==_iInteger2);
		
		Integer _iInteger3=-128;
		Integer _iInteger4=-128;
		System.out.println(_iInteger3==_iInteger4);
		
		Integer _iInteger5=127;
		Integer _iInteger6=127;
		System.out.println(_iInteger5==_iInteger6);
		
		Integer _iInteger7=128;
		Integer _iInteger8=128;
		System.out.println(_iInteger7==_iInteger8);
	}
 
}

输出：

false
true
true
false

代码2——新建对象比较（直接比较new对象，一定为false，与-128 ~ 127范围无关，纯对象比较；拆箱比较，一定为true，与-128 ~ 127范围无关，纯数值比较）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
		Integer _iInteger0=new Integer(0);
		
		Integer _iInteger=new Integer(-129);
		Integer _iInteger2=new Integer(-129);
		System.out.println("新建对象后比较: "+(_iInteger==_iInteger2));
		System.out.println("自动拆箱后比较: "+(_iInteger==_iInteger2+_iInteger0));
		
		Integer _iInteger3=new Integer(-128);
		Integer _iInteger4=new Integer(-128);
		System.out.println("新建对象后比较: "+(_iInteger3==_iInteger4));
		System.out.println("自动拆箱后比较: "+(_iInteger3==_iInteger4+_iInteger0));
		
		Integer _iInteger5=new Integer(127);
		Integer _iInteger6=new Integer(127);
		System.out.println("新建对象后比较: "+(_iInteger5==_iInteger6));
		System.out.println("自动拆箱后比较: "+(_iInteger5==_iInteger6+_iInteger0));
		
		Integer _iInteger7=new Integer(128);
		Integer _iInteger8=new Integer(128);
		System.out.println("新建对象后比较: "+(_iInteger7==_iInteger8));
		System.out.println("自动拆箱后比较: "+(_iInteger7==_iInteger8+_iInteger0));
	}
 
}

输出：

新建对象后比较: false
自动拆箱后比较: true
新建对象后比较: false
自动拆箱后比较: true
新建对象后比较: false
自动拆箱后比较: true
新建对象后比较: false
自动拆箱后比较: true

注意： 当出现运算符的时候，包装类型不可能直接用来运算，所以会进行一次拆箱成为基本数字进行比较，所以变成了两个基本类型之间的比较，仅比较值，则为true。

代码3——基本类型比较（true 栈内存中，数值相等即为true，与常量池无关）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
 
		int _int1 = -129;
		int _int2 = -129;
		System.out.println(_int1 == _int2);
 
		int _int3 = -128;
		int _int4 = -128;
		System.out.println(_int3 == _int4);
 
		int _int5 = 127;
		int _int6 = 127;
		System.out.println(_int5 == _int6);
 
		int _int7 = 128;
		int _int8 = 128;
		System.out.println(_int7 == _int8);
	}
 
}

输出：

true
true
true
true

金手指：Integer/int

第一，基本类型仅比较值，全为true;

第二，新建对象比较引用(即内存地址)，全为false, 运算符拆箱后变为基本类型，全为true;

第三，常量池（编译时类型为包装类型，运行时类型为基本类型）比较介于两者之间，常量池范围内(-128~127)为true,常量池范围外会jvm重新新建对象,故为false。

2.6 Long常量池

代码1——常量池比较（涉及常量池：Long在(-128 ~ 127)使用常量池技术，返回为true，范围外在堆中新建对象，返回为false）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
		Long _iLong = (long) -129;
		Long _iLong2 = (long) -129;
		System.out.println(_iLong == _iLong2);
 
		Long _iLong3 = (long) -128;
		Long _iLong4 = (long) -128;
		System.out.println(_iLong3 == _iLong4);
 
		Long _iLong5 = (long) 127;
		Long _iLong6 = (long) 127;
		System.out.println(_iLong5 == _iLong6);
 
		Long _iLong7 = (long) 128;
		Long _iLong8 = (long) 128;
		System.out.println(_iLong7 == _iLong8);
	}
 
}

输出：

false
true
true
false

代码2——新建对象比较（直接比较new对象，一定为false，与-128 ~ 127范围无关，纯对象比较；拆箱比较，一定为true，与-128 ~ 127范围无关，纯数值比较）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
		Long _iLong0 = new Long(0);
 
		Long _iLong = new Long((long) -129);
		Long _iLong2 = new Long((long) -129);
		System.out.println("新建对象后比较: " + (_iLong == _iLong2));
		System.out.println("自动拆箱后比较: " + (_iLong == _iLong2 + _iLong0));
 
		Long _iLong3 = new Long((long) -128);
		Long _iLong4 = new Long((long) -128);
		System.out.println("新建对象后比较: " + (_iLong3 == _iLong4));
		System.out.println("自动拆箱后比较: " + (_iLong3 == _iLong4 + _iLong0));
 
		Long _iLong5 = new Long((long) 127);
		Long _iLong6 = new Long((long) 127);
		System.out.println("新建对象后比较: " + (_iLong5 == _iLong6));
		System.out.println("自动拆箱后比较: " + (_iLong5 == _iLong6 + _iLong0));
 
		Long _iLong7 = new Long((long) 128);
		Long _iLong8 = new Long((long) 128);
		System.out.println("新建对象后比较: " + (_iLong7 == _iLong8));
		System.out.println("自动拆箱后比较: " + (_iLong7 == _iLong8 + _iLong0));
	}
 
}

输出：

新建对象后比较: false
自动拆箱后比较: true
新建对象后比较: false
自动拆箱后比较: true
新建对象后比较: false
自动拆箱后比较: true
新建对象后比较: false
自动拆箱后比较: true

注意： 当出现运算符的时候，包装类型不可能直接用来运算，所以会进行一次拆箱成为基本数字进行比较，所以变成了两个基本类型之间的比较，仅比较值，则为true。

代码3——基本类型比较（true 栈内存中，数值相等即为true，与常量池无关）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
 
		long _iLong = -129L;
		long _iLong2 = -129L;
		System.out.println(_iLong == _iLong2);
 
		long _iLong3 = -128L;
		long _iLong4 = -128L;
		System.out.println(_iLong3 == _iLong4);
 
		long _iLong5 = 127L;
		long _iLong6 = 127L;
		System.out.println(_iLong5 == _iLong6);
 
		long _iLong7 = 128L;
		long _iLong8 = 128L;
		System.out.println(_iLong7 == _iLong8);
	}
 
}

输出：

true
true
true
true

金手指：Long/long

第一，基本类型仅比较值，全为true;

第二，新建对象比较引用(即内存地址)，全为false, 运算符拆箱后变为基本类型，全为true;

第三，常量池（编译时类型为包装类型，运行时类型为基本类型）比较介于两者之间，常量池范围内(-128~127)为true,常量池范围外会jvm重新新建对象,故为false。

2.7 Float常量池

代码1——常量池比较（涉及常量池：Float无常量池技术，所以在堆中新建对象，所以返回为false）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
 
		Float _fFloat = 1.0f;
		Float _fFloat2 = 1.0f;
		System.out.println(_fFloat == _fFloat2);// false 浮点型没有实现常量池技术
	}
 
}

输出：

false

代码2——新建对象比较（直接比较new对象，一定为false，与-128 ~ 127范围无关，纯对象比较；拆箱比较，一定为true，与-128 ~ 127范围无关，纯数值比较；整个过程与常量池技术无关）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
		Float _fFloat0 = new Float(0.0f);
 
		Float _fFloat = new Float(1.0f);
		Float _fFloat2 = new Float(1.0f);
		System.out.println("新建对象后比较: " + (_fFloat == _fFloat2));
		System.out.println("自动拆箱后比较: " + (_fFloat == _fFloat2 + _fFloat0));
 
	}
 
}

输出：

新建对象后比较: false
新建对象后比较: true

注意： 当出现运算符的时候，包装类型不可能直接用来运算，所以会进行一次拆箱成为基本数字进行比较，所以变成了两个基本类型之间的比较，仅比较值，则为true。

代码3——基本类型比较（true 栈内存中，数值相等即为true，与常量池无关）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
 
		float _float1 = 1.0f;
		float _float2 = 1.0f;
		System.out.println(_float1 == _float2);
 
	}
 
}

输出：

true

金手指：Float/float

第一，基本类型仅比较值，全为true;

第二，新建对象比较引用(即内存地址)，全为false, 运算符拆箱后变为基本类型，全为true;

第三，Float无常量池技术，常量池比较jvm会重新新建对象，故为false。

2.8 Double常量池

代码1——常量池比较（涉及常量池：Double无常量池技术，所以在堆中新建对象，所以返回为false）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
 
		Double _dDouble = 1.0d;
		Double _dDouble2 = 1.0d;
		System.out.println(_dDouble == _dDouble2);// false 浮点型没有实现常量池技术
	}
 
}

输出：

false

代码2——新建变量比较（直接比较new对象，一定为false，与-128 ~ 127范围无关，纯对象比较；拆箱比较，一定为true，与-128 ~ 127范围无关，纯数值比较；整个过程与常量池技术无关）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
		Double _dDouble0 = new Double(0.0d);
 
		Double _dDouble = new Double(1.0d);
		Double _dDouble2 = new Double(1.0d);
		System.out.println("新建对象后比较: " + (_dDouble == _dDouble2));// false 浮点型没有实现常量池技术															
		System.out.println("自动拆箱后比较: " + (_dDouble == _dDouble2 + _dDouble0));
	}
 
}

输出：

新建对象后比较: false
自动拆箱后比较: true

注意： 当出现运算符的时候，包装类型不可能直接用来运算，所以会进行一次拆箱成为基本数字进行比较，所以变成了两个基本类型之间的比较，仅比较值，则为true。

代码3——基本类型比较（true 栈内存中，数值相等即为true，与常量池无关）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
 
		double _dDouble = 1.0d;
		double _dDouble2 = 1.0d;
		System.out.println(_dDouble == _dDouble2);
 
	}
 
}

输出：

true

金手指：Double/double

第一，基本类型仅比较值，全为true;

第二，新建对象比较引用(即内存地址)，全为false, 运算符拆箱后变为基本类型，全为true;

第三，Double无常量池技术，常量池比较jvm会重新新建对象，故为false。

三、引用类型常量池（String常量池）

package mypackage;
 
public class TestConstantPool {
 
	public static void main(String[] args) {
		String s1 = "Hello";
		String s2 = "Hello";
		String s3 = "Hel" + "lo";
		String s4 = "Hel" + new String("lo");
		String s5 = new String("Hello");
		String s6 = s5.intern();   
		String s7 = "H";
		String s8 = "ello";
		String s9 = s7 + s8;   // 
		          
		System.out.println(s1 == s2);  // true   理由：s1和s2右边赋值都是显式写死的，是编译器可以预知的，编译期间，直接放到class文件的常量池中，运行时，指向同一个地址
		System.out.println(s1 == s3);  // true   理由：s1右边是显式写死的，s3也是显式写死的，没有使用变量，所有s1、s3都是编译器可以预见的，编译时放入静态常量池中，指向同一地址
		System.out.println(s1 == s4);  // false  理由：s4右边拼接的时候使用了new String()，编译时不可预知，需要运行时确定，
		System.out.println(s1 == s9);  // false  理由：s9由s7、s8拼接，s7和s8都是变量，编译时不可预知
		System.out.println(s4 == s5);  // false  理由:s4右边使用new String()，编译时不可预知，s5右边也使用new String(),编译时不可预知
		System.out.println(s1 == s6);  // true   理由：s5已经在堆中，s6 = s5.intern();
		//intern方法会尝试将Hello字符串添加到常量池中，并返回其在常量池中的地址，因为常量池中已经有了Hello字符串，所以intern方法直接返回地址；而s1在编译期就已经指向常量池了，因此s1和s6指向同一地址，相等。
	}
 
}

输出：

true    // 两边都有变量，但是没有变量拼接
true   // 两边变量，右边常量拼接
false   // 两边变量，右边变量拼接，有newString() 一定false
false   // 两边都有变量，右边变量拼接，为false,没有intern()和final
false   // 两边都有变量，右边变量拼接，有newString() 一定false
true   两边都有变量，右边变量拼接，但是右边intern()

四、面试金手指

4.1 对象类型

对于八种对象（即boolean character byte short int long float double）：

第一，如果直接比较new对象，一定为false，与-128 ~ 127范围无关，纯对象比较；

第二，对于拆箱：short int long float double （即后面五种）拆箱比较，一定为true，与-128 ~ 127范围无关，纯数值比较（拆箱比较等同于下面的基本数据类型比较，全为true），整个过程与常量池技术无关。

4.2 基本类型

对于基本类型（boolean char byte short int long float double）都栈内存上，不涉及-128 ~ 127的数值范围，与常量池技术无关。

4.3 常量池技术

对于六种类型使用的常量池技术：

boolean 全部为true 取值就两个；

Character 0-127 全部为true 超出为false；

byte -128~127 为true,但是它的取值范围就是这样，所有全部为true；

Short Integer Long -128 ~ 127 全部为true，其他为false；

Float Double 全部为false，没有常量池技术，都要在堆上新建。

五、尾声

各种数据类型的常量池技术，完成了。

天天打码，天天进步！！！

祖母绿宝石
关注
专栏目录
深入理解JVM虚拟机第二十四篇：详解JVM当中的动态链接和常量池的作用
七叔的博客
11-12 920
本文是深入理解JVM虚拟机第二十四篇，详细讲解了JVM当中的动态链接和常量池的作用
.class字节码类型识别：魔数、常量池和内存模型
大力海棠的博客
07-13 632
目录 .class文件 组成结构 魔数 常量池 oop-klass模型 我们都知道C语言执行依赖编译器，同一段C程序，在不同的操作系统平台（或者说是硬件平台上）上，由不同的编译器将其编译成对应的机器指令，编译后的C程序里各种数据类型信息都被改写成汇编，这是在编译时期完成的，在编译器对C程序进行解析时，识别里面的各种数据类型，例如结构体，并翻译成机器可以理解的二进制程序，待操作系统加载执行。Java则不同，JIT即时编译器虽然也能在编译时识别出Java程序中的各种数据类型信息，但是还记...
运行时常量池_各种数据类型的常量池技术
weixin_39633493的博客
12-19 122
一、前言Java中常量池大体可以分为：静态常量池，运行时常量池。class文件常量池：存在于class文件中，如经常使用的javap -verbose中；运行时常量池：就是在class文件被加载进了内存之后，常量池保存在了方法区中。通常说的常量池指的是运行时常量池，本文讨论的都是运行时常量池。二、基本类型常量池Java中基本类型的常量池技术不是由基本类型实现的，而是由基本类型对应的包装类型实现的。...
JAVA-基础知识-基础数据类型，常量池
横行的螃蟹的博客
10-26 304
JAVA-基础知识-基础数据类型，常量池 基础类型有这样一张表就差不多了 类型 包装类 默认值 最大值 最小值 长度 描述 byte Byte 0 127(2^7-1) -128(-2^7) 8 有符号的，以二进制补码表示的整数 boolean Boolean false 1 boolean只有两个取值：true 和 false short Short 0 32767(...
java封装类运算_Java 基本类型、封装类型、常量池、基本运算
weixin_35918198的博客
02-13 287
一、基本数据类型：byte：Java中最小的数据类型，在内存中占8位(bit)，即1个字节，取值范围-128~127，默认值0short：短整型，在内存中占16位，即2个字节，取值范围-32768~32717，默认值0int：整型，用于存储整数，在内在中占32位，即4个字节，取值范围-2147483648~2147483647，默认值0long：长整型，在内存中占64位，即8个字节-2^63~2^...
8种基本数据类型的包装类中那些拥有常量池技术？
qq_44185887的博客
09-19 485
基本数据类型和对应的包装类 基本数据类型 包装类 byte Byte short Short int Integer long Long float Float double Double char Character boolean Boolean 其中double 和float两种浮点型包装类不具有常量池技术。 什么是常量池技术？ 例如：Integer i1 = 40；Java在编译的时候会直接将代..
整数型常量池
weixin_42294525的博客
08-02 415
java中为了提高程序的执行效率，将-128到127之间的所有包装类提前创建好，放到了方法区的常量池中，目的是这个区间的数字不需要再new对象，直接从整形常量池中取出来。
面试复习之—Java基础（二）:基本数据类型与常量池
尼尧Nier的博客
05-24 461
最近在准备面试，把知识点复习一遍，整理出的笔记记录下，里面会穿插代码和面试例题。 内容不是原创，是总结和收集，如果侵权了请联系作者，若有错误也请各位指正。因为收集的时候忘记把来源记录下来了，所以就不po出处了，请见谅（这是个坏习惯，一定改）。 面试复习之—Java基础（二）:基本数据类型与常量池一、基本数据类型1、Java数据类型2、Java自动拆箱和自动装箱3、Java中整形的缓存机制二、 常量池1、常量池概念2、常量池的好处3、常量池的位置4、例题 这是面试复习内容的第二篇——基本数据类型与常量池，
深入理解Java String：源码剖析与常量池详解
"这篇文章除了介绍Java中的String类，还深入解析了String常量池的概念。文章通过实例和源码分析，帮助读者理解String对象的特性以及常量池的工作原理。" 在Java编程中，`String` 类是一个非常重要的类，因为它被...
class常量池类型分类.pdf
最新发布
02-14
由于这两种数据类型都是64位的，所以它们需要占用常量池中的两个槽（slot）。这意味着如果在常量池中添加了一个`CONSTANT_Long_info`或`CONSTANT_Double_info`，那么紧接着的下一个有效索引将是当前索引加上2。 ###...
java中-128~127数字常量池
qq_37156624的博客
07-07 1021
java中的自动装箱和自动拆箱是jdk1.5中出现的，可以在程序编译期自动将基本数据类型转换为包装类型。 有如下代码：
Integer常量池
缘自天方的博客
08-13 1525
在Java中有8中基本数据类型，基本类型是分配在栈空间上的，Java为我们提供了分配在堆栈空间的8种基本类型的包装类（Byte、Short、Integer、Long、Float、Double、Boolean、Character），这些包装类的实例对象除了包装的数据不一样外，其他的没有很明显的差别。  就以Integer为例，各个Integer对象的差别在于包装的int类型的值不同而已，假设Jav
简单聊聊java中各种常量池
qq_40589140的博客
11-09 289
基本类型的包装类的常量池：Java中有6种基本类型的包装类型实现了常量池技术，分别是Byte,Short,Integer,Long,Character,Boolean，其中Byte,Short,Integer,Long,Character这5种整型的包装类只是在对应值小于等于127时才可使用对象池。另外两种浮点数类型的包装类型没有实现。包装类型在进行运算时可能会自动拆箱三种常量池：Class文件常量池（字面量，符号引用），其中字面量的概念需要重点掌握。运行时常量池字符串常量池字符串常量池。
讲讲“池”的概念---线程池，数据库连接池，常量池
weixin_34128534的博客
02-28 218
1.池，说白了就是提前创建好了东西放在池子里，你直接去池子里拿去用就行了，有现成的可用的，节省了你临时创建的时间。 2.jdbc connection，线程thread，对象，这些东西的创建和销毁都是很消耗时间的，所以我们一般都是提前创建好很多这种创建消耗高的东西，用的时候直接去用就行。 3.数据库连接池用的地方是：mybatis/hibernate这种sql语句操作时，临时创建connect...
==运算符和equals()方法的区别、数字常量池IntegerCache
PureUnicorn的博客
08-16 269
==运算符和equals()方法的区别、数字常量池IntegerCache 文章目录==运算符和equals()方法的区别、数字常量池IntegerCache==比较运算符：对象比较内存地址，基本数据类型比较值相等equals()方法Object.equals()方法源码重写了equals的类IntegerCache数字常量池来龙去脉[public static Integer valueOf(i...
《性能调优之JVM》❤️04JVM常量池详解之深入理解Class常量池、运行时常量池、字符串常量池、八种基本数据类型的包装类和对象池
weixin_46460843的博客
09-05 410
JVM常量池详解：深入理解Class常量池、运行时常量池、字符串常量池一、Class常量池2.1字面量2.2符号引用二、运行时常量池三、字符串常量池3.1设计思想3.2设计原理3.3字符串常量池位置3.４三种字符串操作 一、Class常量池 Class常量池就像Class文件中的资源仓库。包含类的版本、字段、方法、接口等描述信息， 以及常量池。常量池用于存放编译期生成的各种字面量和符号引用等信息。 2.1字面量 字面量指的是由字母、数字等构成的字符串或者数值常量。 字面量只可以右值出现，所谓右值是指等号右边
池化思想：字符串常量池，线程池，数据库连接池
ZJH
02-14 501
池化思想 资源反复利用，用后归还，免去大量建立销毁浪费的时间和资源，建立和销毁占用的资源还是很多的 字符串常量池 常量池独立于栈和堆，以下两种创建方式区别 1，直接保存常量池的内容 String s1 = “直接保存” 2，new String间接保存 String s2 = new String(“间接保存”) 区别： 直接保存，无论创建多少个都是相同的 间接保存实际上保存的是地址值，指向线程池，此方式会产生两个对象；如果多次间接保存，例如： String s3 = new String(“间接保存”)
Java中几种常量池的区分
阿官
06-01 389
Java中几种常量池的区分原文链接：http://tangxman.github.io/2015/07/27/the-difference-of-java-string-pool/           在java的内存分配中，经常听到很多关于常量池的描述，我开始看的时候也是看的很模糊，网上五花八门的说法简直太多了，最后查阅各种资料，终于算是差不多理清了，很多网上说法都有问题，笔者尝试着来区分一下这...
关于常量池和运行时常量池
轨迹_Mine的博客
12-25 1436
前言 最近在学习JVM运行时数据区的方法区的相关知识，其中涉及到常量池和运行时常量池，所以就把相关知识整理一下。 一、常量池是什么？ 常量池是字节码文件的一部分。JVM为每一个已经被加载的类型（类或者接口）都维护一个常量
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

祖母绿宝石

打赏一下

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值