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！