JAVA常量池技术

 1、常量池的概念

Java 是一种动态连接语言，在Java程序中，有很多的东西是永恒的，不会在运行过程中变化。而这些在JVM解释执行程序的时候是非常重要的。那么编译器将源程序编译成class文件后，会用一部分字节分类存储这些代码。而这些字节我们就称为常量池。

常量池的出现是为了方便快捷地创建某些对象而出现的，当需要一个对象时，就可以从池中取一个出来（如果池中没有则创建一个），则在需要重复创建相等变量时节省了很多时间。

 2、常量池的位置
 根据《深入JAVA虚拟机》书中描述：常量池是属于类型信息的一部分，类型信息也就是每一个被转载的类型，这个类型反映到JVM内存模型中是对应存在于JVM内存模型的方法区中，也就是这个类型信息中的常量池概念是存在于在方法区中，而方法区是在JVM内存模型中的堆中由JVM来分配的。所以，haha的值是应该是存在堆空间中的。

 

3、常量池中的内容
常量池中除了包含代码中所定义的各种基本类型（如int、long等等）和对象型（如String及数组）的常量值还，还包含一些以文本形式出现的符号引用，比如：
 类和接口的全限定名；    
 字段的名称和描述符；
 方法的名称和描述符。

 

3.1、八种基本类型的包装类和对象池

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

 

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

		}
}

 

3.2、String也实现了常量池技术

String类也是java中用得多的类，同样为了创建String对象的方便，也实现了常量池的技术,
用new String（）创建的字符串不是常量，不能在编译期就确定，所以new String（）创建的字符串不放入常量池中，他们有自己的地址空间。
String 对象（内存）的不变性机制会使修改String字符串时，产生大量的对象，因为每次改变字符串，都会生成一个新的String。 java 为了更有效的使用内存，常量池在编译期遇见String 字符串时，它会检查该池内是否已经存在相同的String 字符串，如果找到，就把新变量的引用指向现有的字符串对象，不创建任何新的String 常量对象，没找到再创建新的。所以对一个字符串对象的任何修改，都会产生一个新的字符串对象，原来的依然存在，等待垃圾回收。

下面是几个常见例子的比较分析和理解：

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

1分析：JVM对于字符串常量的"+"号连接，将程序编译期，JVM就将常量字符串的"+"连接优化为连接后的值，拿"a" + 1来说，经编译器优化后在class中就已经是a1。在编译期其字符串常量的值就确定下来，故上面程序最终的结果都为true。

 

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

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

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。

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 采用连接运算符（+）效率低下原因分析，形如这样的代码：
 

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方法理解和分析：
 

class Test
{
	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的值相等。