在jvm规范中，每个类型都有自己的常量池。常量池是某类型所用常量的一个有序集合，包括直接常量（基本类型，String）和对其他类型、字段、方法的符号引用。之所以是符号引用而不是像c语言那样，编译时直接指定其他类型，是因为java是动态绑定的，只有在运行时根据某些规则才能确定具体依赖的类型实例，这正是java实现多态的基础。
为了对常量池有更具体的认识，下面引用几个例子：
1,常量池中对象和堆中的对象
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
2，8种基本类型的包装类和对象池
java中基本类型的包装类的大部分都实现了常量池技术，这些类是Byte, Short, Integer, Long, Character, Boolean, 另外两种浮点数类型（Float、Double）的包装类则没有实现。另外Byte, Short, Integer, Long, Character这5种整型的包装类也只在大于等于-128并且小于等于127时才使用常量池，也即对象不负责创建和管理大于127的这些类的对象。以下是一些对应的测试代码：
//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
当我们给Integer赋值时，实际上调用了Integer.valueOf(int)方法，查看源码，其实现如下：
public static Integer valueOf(int i) { if(i >= -128 && i <= IntegerCache.high) return IntegerCache.cache[i + 128]; else return new Integer(i); }
而IntegerCache实现如下：
private static class IntegerCache { static final int high; static final Integer cache[]; static { final int low = -128; // high value may be configured by property int h = 127; if (integerCacheHighPropValue != null) { // Use Long.decode here to avoid invoking methods that // require Integer's autoboxing cache to be initialized int i = Long.decode(integerCacheHighPropValue).intValue(); i = Math.max(i, 127); // Maximum array size is Integer.MAX_VALUE h = Math.min(i, Integer.MAX_VALUE - -low); } high = h; cache = new Integer[(high - low) + 1]; int j = low; for(int k = 0; k < cache.length; k++) cache[k] = new Integer(j++); } private IntegerCache() {} }
cache数组是静态的。
3.String也实现了常量池技术
String类也是java中用得多的类，同样为了创建String对象的方便，也实现了常量池的技术,测试代码如下:
//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
4.Integer面试题
public class IntegerTest { public static void main(String[] args) { // TODO Auto-generated method stub Integer i11 = 127; Integer i12 = 127; Integer i13 = 0; Integer i14 = new Integer(127); Integer i15 = new Integer(127); Integer i16 = new Integer(0); System.out.println("i11=i12\t" + (i11 == i12)); System.out.println("i11=i12+i13\t" + (i11 == i12 + i13)); System.out.println("i14=i15\t" + (i14 == i15)); System.out.println("i14=i15+i16\t" + (i14 == i15 + i16)); } }
输出结果：
i11=i12 true
i11=i12+i13 true
i14=i15 false
i14=i15+i16 true
解析：
Integer已经默认创建了数值【-128-127】的Integer缓存数据，所以使用Integer i11=127时，JVM会直接在该在对象池找到该值的引用，i12也是，所以i11=i12，都是从对象缓存池中取得该对象引用。但是i14和i15每次都会重新Create新的Integer对象，不会被放入到对象池中，所以他们不是同一个引用，输出false
对于i11==i12+i13、i14==i15+i16结果为True，是因为，Java的数学计算是在内存栈里操作的，Java会对i15、i16进行拆箱操作，其实比较的是基本类型（127=127+0），他们的值相同，因此结果为True
把127换成128运行结果是：
i11=i12 false
i11=i12+i13 true
i14=i15 false
i14=i15+i16 true
因为128不在Integer对象缓冲池中，所以每次都创建新的Integer（128）对象，所以i11也就不等于i12了。
5.字符串比较更丰富的一个例子
public class AAA { public static void main(String[] args) { // TODO Auto-generated method stub String hello = "Hello", lo = "lo"; System.out.print((hello == "Hello") + " "); System.out.print((Other.hello == hello) + " "); System.out.print((other.Other.hello == hello) + " "); System.out.print((hello == ("Hel" + "lo")) + " "); System.out.print((hello == ("Hel" + lo)) + " "); System.out.println(hello == ("Hel" + lo).intern()); } } class Other { static String hello = "Hello"; }
package other; public class Other { static String hello = "Hello"; }
输出结果：
true true true true false true
输出结果的分别解释如下：
在同包同类下,引用自同一String对象.
在同包不同类下,引用自同一String对象.
在不同包不同类下,依然引用自同一String对象
在编译成.class时能够识别为同一字符串的,自动优化成常量,所以也引用自同一String对象
在运行时创建的字符串具有独立的内存地址,所以不引用自同一String对象
String的intern()方法会查找在常量池中是否存在一份equal相等的字符串,如果有则返回一个引用,没有则添加自己的字符串进进入常量池,
注意,只是字符串部分,所以这时会存在2份拷贝,常量池的部分被String类私有持有并管理,自己的那份按对象生命周期继续使用.