JAVA的内存

1. 寄存器：最快的存储区 , 由编译器根据需求进行分配 , 我们在程序中无法控制 .
2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（ new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）
3. 堆：存放所有 new 出来的对象。
4. 静态域：存放静态成员（ static 定义的）
5. 常量池：存放字符串常量和基本类型常量（ public static final ） 。
6. 非 RAM 存储：硬盘等永久存储空间

我们主要关心栈，堆和常量池，对于栈和常量池中的数据时可以共享，对于堆中的对象是不可以共享。栈中的数据大小和生命周期是可以确定的，当没有引用指向数据时，这个数据就会被销毁。堆中的对象的由垃圾回收器负责回收，因此大小和生命周期不需要确定。

字符串
对于字符串存储是比较特殊：其对象的引用都是存储在栈中的，如果是编译期已经创建好 ( 直接用双引号定义的 ) 的就存储在常量池中，如果是运行期（ new 出来的）才能确定的就存储在堆中。 在常量池中永远只有一份，在堆中有多份 。
我们来看一些例子：
例1：

String s1 = "hello";
String s2 = "hello";
String ss1 = new String("hello");
String ss2 = new String("hello");

1.s1==s2和s1.equals(s2)都返回true(这里要注意==是比较变量的值-因为s1和s2的值在这里就是对象的引用也就是对象的地址所以返回true，equals是比较对象-对象是相同的当然是返回true了)，同理可以得出ss1==ss2返回false,s1.equals(ss1)和ss1.equals(ss2)都返回true。
2.两根蓝色的线的作用，对于通过 new 产生一个字符串（假设为 "hello"）时，会先去常量池中查找是否已经有了 "hello"对象，如果没有则在常量池中创建一个此字符串对象，然后堆中再创建一个常量池中此 "hello"对象的拷贝对象。这也就是有道面试题： String s = new String( "hello"); 产生几个对象？一个或两个，如果常量池中原来没有” xyz ” , 就是两个。
例2：

String s0="hello";   
String s1="hello";   
String s2="he" + "llo";   
System.out.println(s0==s1);   //result true
System.out.println(s0==s2);   //result true

分析： s0和s1中的”hello”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”he ”和”llo”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中”hello”的一个引用。所以我们得出s0==s1==s2；用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中。
例3：

String s0="hello";   
String s1=new String("hello");   
String s2="he" + new String("llo");   
System.out.println(s0==s1);   //result false
System.out.println(s0==s2);   //result false
System.out.println(s1==s2);   //result false

分析：s0还是常量池 中"hello”的应用，s1因为无法在编译期确定，所以是运行时创建的新对象”hello”的引用，s2因为有后半部分 new String(”llo”)所以也无法在编译期确定，所以也是一个新创建对象”hello”的应用;所以得此结果。
例4：

String s0= "hello";   
String s1=new String("hello");   
String s2=new String("hello");   
System.out.println(s0==s1);             //result false
s1.intern();   
s2=s2.intern(); 
System.out.println(s0==s1);           //result false       
System.out.println(s0==s1.intern());  //result true
System.out.println(s0==s2);           //result true

分析：String的 intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java 查找常量池中 是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常 量池中增加一个Unicode等于str的字符串并返回它的引用   第二次执行System.out.println(s0==s1); 虽然执行了s1.intern(),但它的返回值没有赋给s； System.out.println(s0==s1.intern()); 说明s1.intern()返回的是常量池中"kvill"的引用
例5：

String a = "a1";   
String b = "a" + 1;   
System.out.println((a == b)); //result = true 

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

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

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

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

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

引用

String a = "abcd";  
final String c = createC();  
String b = "ab" + c;  
System.out.println((a == b)); //result = false  
private static String createC() { 
return "cd";

分析：JVM对于字符串引用c，它的值在编译期无法确定，只有在程序运行期调用方法后，将方法的返回值和"ab"来动态连接并分配地址为b，故上面 程序的结果为false。

基本类型和包装类：
直接看例子：
例1：

int i1 = 5;
int i2 = 5;
final int i3 = 5;
Integer i4 = 5;
Integer i5 = new Integer(5);

int ii1 = 500;
int ii2 = 500;
Integer ii3 = 500;
Integer ii4 = new Integer(500);

分析：存放基本类型的变量数据和对象的引用，请注意：
1.final int i3 = 5 一个基本类型常量放在常量池中，所以在栈中有一个引用指向它；Integer i4是一个对象但在栈中创建是因为java5开始包装类和相应的基本类型之间可以自动装箱和拆箱；Integer i5是new一个对象，我们都知道new出来的对象是存放在堆里，为什么这里存放在栈中呢，是因为对于基本类型在堆中new一个对象，特别是小的简单变量，不是很有效，所以java不直接在堆中new对象，而是直接在栈中赋值（条件是大小在1个字节以内），当大小大于1个字节时则是在堆中new对象例如题中的Integer ii4；在栈中相同的基本类型变量只创建一次，变量5同时赋值给i1, i2, i4, i5；
自动装箱与拆箱的功能事实上是编译器来帮您的忙，编译器在编译时期依您所编写的语法，决定是否进行装箱或拆箱动作。例如：
Integer x = 1 ; x = x  + 1;     //装箱 -> 拆箱 -> 装箱
例2：

char c1 = 'a';       
Character c2 = 'a';    
System.out.println(c2 == c1);  // result ture;

分析：在java1.4环境下Character c2 = 'a'; 不能编译通过，我们都知道对象是需要new出来的，所以不能通过，而java5环境下可以编译通过（包装类和相应的基本类型之间 自动装箱与拆箱），Character c2 = 'a'; 装箱   System.out.println(c2 == c1);拆箱再比较，所以能编译通过且结果为true.
例3：

char c1 = 'a';
Character c2 = new Character('a');
System.out.println(c1 == c2);

  // java1.4下这里不能编译通过，java5则可以 同样拆箱后再比较 result ture;

总结
栈中用来存放一些基本数据类型的局部变量数据和对象的引用(String,数组.对象等等)但不存放对象内容
堆中存放使用new关键字创建的对象.
字符串是一个特殊包装类,其引用是存放在栈里的,而对象内容必须根据创建方式不同定(常量池和堆).有的是编译期就已经创建好，存放在字符串常量池中，而有的是运行时才被创建.使用new关键字，存放在堆中。
基础类型包装类直接赋值通过装箱直接在栈内创建且只创建一次，new一个对象当小于一个字节的时候在栈中创建，否则在堆中创建。
Java 的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建 立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分 配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。
       栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本 类型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄。
   
         可见，垃圾回收GC是针对堆Heap的，而栈因为本身是FILO - first in, last out. 先进后出，能够自动释放。 这样就能明白到new创建的，都是放到堆Heap！


转自：http://aayy520.blog.163.com/blog/static/23182260201111244051199/?latestBlog