一：栈，堆以及常量池的概念：
1、栈区（stacksegment）—由编译器自动分配释放,存放函数的参数值，局部变量的值等，具体方法执行结束之后，系统自动释放JVM内存资源 2、堆区（heapsegment）—一般由程序员分配释放，存放由new创建的对象和数组，jvm不定时查看这个对象，如果没有引用指向这个对象就回收 3、静态区（datasegment）—存放全局变量，静态变量和字符串常量，不释放 4、代码区（codesegment）—存放程序中方法的二进制代码，而且是多个对象共享一个代码空间区域
一：在class文件中，“常量池”是最复杂也最值得关注的内容。
Java是一种动态连接的语言，常量池的作用非常重要，常量池中除了包含代码中所定义的各种基本类型（如int、long等等）和对象型（如String及数组）的常量值还，还包含一些以文本形式出现的符号引用，比如：
类和接口的全限定名；
字段的名称和描述符；
方法和名称和描述符。
在C语言中，如果一个程序要调用其它库中的函数，在连接时，该函数在库中的位置（即相对于库文件开头的偏移量）会被写在程序中，在运行时，直接去这个地址调用函数；
编译时，如果发现对其它类方法的调用或者对其它类字段的引用的话，记录进class文件中的，只能是一个文本形式的符号引用，在连接过程中，虚拟机根据这个文本信息去查找对应的方法或字段。
所以，与Java语言中的所谓“常量”不同，class文件中的“常量”内容很非富，这些常量集中在class中的一个区域存放，一个紧接着一个，这里就称为“常量池”。
常量池其实也就是一个内存空间，不同于使用new关键字创建的对象所在的堆空间。本文只从java使用者的角度来探讨java常量池技术，并不涉及常量池的原理及实现方法。个人认为，如果是真的专注java,就必须对这些细节方面有一定的了解。但知道它的原理和具体的实现方法则不是必须的。
常量池中对象和堆中的对象
[java] view plain copy
1. public class Test{
2.
3. Integer i1=new Integer(1);
4. new Integer(1);
5. //i1,i2分别位于堆中不同的内存空间
6.
7. //输出false
8.
9.
10. 1;
11. 1;
12. //i3,i4指向常量池中同一个内存空间
13.
14. //输出true
15.
16. //很显然，i1,i3位于不同的内存空间
17.
18. System.out.println(i1==i3);//输出false
19.
20. }
8种基本类型的包装类和对象池
java中基本类型的包装类的大部分都实现了常量池技术，这些类是Byte,Short,Integer,Long,Character,Boolean,另外两种浮点数类型的包装类则没有实现。另外Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127时才可使用对象池，也即对象不负责创建和管理大于127的这些类的对象。
这就是我这篇博客要说的java常量池的小陷阱了！
Byte , Short，Integer，Long，Characher ，Boolean。Double和Float没有实现，佐证如下图：
图三
直接定义常量是会报错的
这5种包装类在常量池的实现上与String有点区别，以Integer为例，当有Integer i=127时，实际上发生了如下操作：
Integer i=Integer.valueOf(127)
减少对象创建次数和节省内存的考虑，缓存了[-128,127]之间的数字。此数字范围内传参则直接返回缓存中的对象。在此之外，直接new出来.
127 （小于或者等于），超过127常量池就不予自动创建对象，这时包装类就和普通的引用类型没有区别了。
以下是一些对应的测试代码：
[java] view plain copy
1. public class Test{
2.
3. public static void main(String[] args){
4.
5. //5种整形的包装类Byte,Short,Integer,Long,Character的对象，
6.
7. //在值小于127时可以使用常量池
8.
9. 127;
10.
11. 127;
12.
13. //输出true
14.
15. //值大于127时，不会从常量池中取对象
16.
17. 128;
18.
19. 128;
20.
21. //输出false
22.
23. //Boolean类也实现了常量池技术
24.
25. true;
26.
27. true;
28.
29. //输出true
30.
31. //浮点类型的包装类没有实现常量池技术
32.
33. 1.0;
34.
35. 1.0;
36.
37. //输出false
38.
39.
40.
41. }
42.
43. }
String也实现了常量池技术
String类也是java中用得多的类，同样为了创建String对象的方便，也实现了常量池的技术,测试代码如下:
[java] view plain copy
1. public class Test{
2.
3. public static void main(String[] args){
4.
5. //s1,s2分别位于堆中不同空间
6.
7. String s1=new String("hello");
8.
9. String s2=new String("hello");
10.
11. System.out.println(s1==s2)//输出false
12.
13. //s3,s4位于池中同一空间
14.
15. String s3="hello";
16.
17. String s4="hello";
18.
19. System.out.println(s3==s4);//输出true
20.
21. }
22.
23. }
最后
细节决定成败，写代码更是如此。
在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
1. public static Integer valueOf(int i) {
2. final int offset = 128;
3. if (i >= -128 && i <= 127) { // must cache
4. return IntegerCache.cache[i + offset];
5. }
6. return new Integer(i);
7. }
8.
9.
10. private static class IntegerCache {
11.
12.
13.
14. private IntegerCache(){}
15. static final Integer cache[] = new Integer[-(-128) + 127 + 1];
16. static {
17. for(int i = 0; i < cache.length; i++)
18. new Integer(i - 128);
19. }
20. }
由于cache[]在IntegerCache类中是静态数组，也就是只需要初始化一次，即static｛......｝部分，所以，如果Integer对象初始化时是-128~127的范围，就不需要再重新定义申请空间，都是同一个对象---在IntegerCache.cache中，这样可以在一定程度上提高效率。
